@extrahorizon/javascript-sdk 8.2.0-test

package/build/types/services/tasks/apiRequests/types.d.ts

@@ -0,0 +1,83 @@
+import { FindAllIterator } from '../../helpers';
+import { ObjectId, OptionsWithRql, PagedResultWithPager } from '../../types';
+import { ApiFunctionRequestMethod } from '../api/types';
+import { ApiRequestLogsService } from './logs/types';
+export interface ApiRequestService {
+    /**
+     * ## Retrieve a paged list of API Requests
+     *
+     * **Global Permissions:**
+     * - `VIEW_API_FUNCTION_REQUESTS` - Allows a user to view API Requests
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns A paged list of API Requests {@link PagedResultWithPager PagedResultWithPager<ApiRequest>}
+     */
+    find(options?: OptionsWithRql): Promise<PagedResultWithPager<ApiRequest>>;
+    /**
+     * ## Retrieve a list of all API Requests
+     *
+     * **Global Permissions:**
+     * - `VIEW_API_FUNCTION_REQUESTS` - Allows a user to view API Requests
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An array of API Requests {@link ApiRequest ApiRequest[]}
+     * @throws {@link Error} Do not pass in limit operator with findAll
+     */
+    findAll(options?: OptionsWithRql): Promise<ApiRequest[]>;
+    /**
+     * ## Retrieve a paged list of API Requests
+     *
+     * **Global Permissions:**
+     * - `VIEW_API_FUNCTION_REQUESTS` - Allows a user to view API Requests
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An iterator for the queried API Requests {@link FindAllIterator FindAllIterator<ApiRequest>}
+     */
+    findAllIterator(options?: OptionsWithRql): FindAllIterator<ApiRequest>;
+    /**
+     * ## Retrieve the first queried API Request
+     *
+     * **Global Permissions:**
+     * - `VIEW_API_FUNCTION_REQUESTS` - Allows a user to view API Requests
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns The first element of the queried API Requests {@link ApiRequest}
+     */
+    findFirst(options?: OptionsWithRql): Promise<ApiRequest>;
+    logs: ApiRequestLogsService;
+}
+export interface ApiRequest {
+    /** The Extra Horizon document id */
+    id: ObjectId;
+    /** The unique identifier amongst all Functions */
+    functionName: string;
+    /**  The HTTP method used to target the API function. */
+    method: ApiFunctionRequestMethod;
+    /** The path portion of the URL that comes after the Function name. */
+    path: string;
+    /** The id of the user making the request */
+    userId?: ObjectId;
+    /** The application id of the oAuth application */
+    applicationId?: ObjectId;
+    /** The status code of the API Function's response or of a thrown error during its lifecycle */
+    statusCode: number;
+    /** The time the API Function was executed */
+    timestamp: Date;
+    /** The duration of the API Function execution in seconds */
+    duration: number;
+    /** An error thrown during the lifecycle of the API Function's execution  */
+    error?: ApiRequestError;
+}
+export interface ApiRequestError {
+    /** The name of the caught error */
+    name: string;
+    /** The message of the caught error */
+    message: string;
+    /** The error type defines where the error occurred during the API Function lifecycle and can have one of the following values:
+     * - `invocation` - errors that occur before invocation of the API Function
+     * - `runtime` - errors that occur during the execution of the API Function
+     * - `response` - errors that occur during the response validation after the API Function has been executed
+     */
+    type: ApiRequestErrorType;
+}
+export declare enum ApiRequestErrorType {
+    INVOCATION = "invocation",
+    RUNTIME = "runtime",
+    RESPONSE = "response"
+}

package/build/types/services/tasks/functions/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { FunctionsService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => FunctionsService;
+export default _default;

package/build/types/services/tasks/functions/types.d.ts

@@ -0,0 +1,27 @@
+import { OptionsBase } from '../../types';
+import { Task } from '../types';
+export interface FunctionsService {
+    /**
+     * ## Execute a Function directly
+     *
+     * A Function may be executed directly, the function will be executed synchronously and the response may be awaited by the caller.
+     *
+     * **Default Permissions:**
+     * - Any party may execute Functions with the `public` permission mode
+     * - Any authenticated user may execute Functions with the `allUsers` permission mode
+     *
+     * **Global Permissions:**
+     * - `EXECUTE_TASK_FUNCTION` - A user may execute all Functions
+     * - `EXECUTE_TASK_FUNCTION:{FUNCTION_NAME}` - A user may execute the Function specified by the FUNCTION_NAME
+     *
+     * @param functionName {@link string} - The functionName property serves as the unique identifier amongst all Functions
+     * @param data {@link U} - The data to be sent to the Function, the type may be specified by the user
+     * @param options {@link OptionsBase} - Additional options for the request
+     * @returns {@link DirectExecutionResponse} - The response returned from the Function, the response data and results may be user defined
+     */
+    execute<T = any, U = any>(functionName: string, data?: U, options?: OptionsBase): Promise<DirectExecutionResponse<T, U>>;
+}
+export interface DirectExecutionResponse<T, U> extends Task<U> {
+    /** The result of the Function execution, this may be user defined */
+    result: T;
+}

package/build/types/services/tasks/index.d.ts

@@ -0,0 +1,15 @@
+import { ApiRequestService } from '../../types';
+import type { ApiService, FunctionsService, HttpInstance, LogsService, SchedulesService } from '../../types';
+import api from './api';
+import apiRequests from './apiRequests';
+import functions from './functions';
+import logs from './logs';
+import schedules from './schedules';
+import { TasksService } from './types';
+export declare const tasksService: (httpWithAuth: HttpInstance) => TasksService & {
+    schedules: SchedulesService;
+    functions: FunctionsService;
+    api: ApiService;
+    logs: LogsService;
+    apiRequests: ApiRequestService;
+};

package/build/types/services/tasks/logs/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { LogsService } from './types';
+declare const _default: (client: HttpClient, httpWithAuth: HttpInstance) => LogsService;
+export default _default;

package/build/types/services/tasks/logs/types.d.ts

@@ -0,0 +1,28 @@
+import { ObjectId, OptionsWithRql } from '../../types';
+export interface LogsService {
+    /**
+     * ## Retrieve a list of logs for a task
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_LOGS` - **Required** for this endpoint
+     *
+     * @param taskId {@link string} The id of the targeted task
+     * @param options {@link OptionsWithRql} - Additional options for the request
+     * @returns An array of task logs {@link LogLine LineLog[]}
+     */
+    find(taskId: ObjectId, options?: OptionsWithRql): Promise<LogLine[]>;
+    /**
+     * ## Retrieve the first queried task log
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_LOGS` - **Required** for this endpoint
+     *
+     * @param taskId {@link string} The id of the targeted task
+     * @param options {@link OptionsWithRql} - Additional options for the request
+     * @returns The first element of the queried task logs {@link LogLine}     */
+    findFirst(taskId: ObjectId, options?: OptionsWithRql): Promise<LogLine>;
+}
+export interface LogLine {
+    message: string;
+    timestamp: Date;
+}

package/build/types/services/tasks/schedules/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpInstance } from '../../../http/types';
+import { HttpClient } from '../../http-client';
+import { SchedulesService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => SchedulesService;
+export default _default;

package/build/types/services/tasks/schedules/types.d.ts

@@ -0,0 +1,88 @@
+import { FindAllIterator } from '../../helpers';
+import { AffectedRecords, ObjectId, OptionsBase, OptionsWithRql, PagedResultWithPager } from '../../types';
+export interface SchedulesService {
+    /**
+     * ## Create a new Schedule
+     *
+     * **Global Permissions:**
+     * - `CREATE_TASK_SCHEDULE` - Allows a user to create schedules
+     *
+     * @param schedule - The data used to create the schedule
+     * @param options - Additional options for the request
+     */
+    create<T>(schedule: ScheduleCreation<T>, options?: OptionsBase): Promise<Schedule<T>>;
+    /**
+     * ## Delete a Schedule
+     *
+     * **Global Permissions:**
+     * - `DELETE_TASK_SCHEDULE` - Allows a user to delete schedules
+     *
+     * @param scheduleId - The id of the schedule to delete
+     * @param options - Additional options for the request
+     */
+    delete(scheduleId: ObjectId, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * ## Retrieve a paged list of schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns A paged list of schedules {@link PagedResultWithPager PagedResultWithPager<Schedule>}
+     */
+    find<T>(options?: OptionsWithRql): Promise<PagedResultWithPager<Schedule<T>>>;
+    /**
+     * ## Retrieve a list of all Schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An array of Schedules {@link Schedule Schedule[]}
+     * @throws {@link Error} Do not pass in limit operator with findAll
+     */
+    findAll<T>(options?: OptionsWithRql): Promise<Schedule<T>[]>;
+    /**
+     * ## Retrieve a paged list of Schedules
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view Schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns An iterator for the queried schedules {@link FindAllIterator FindAllIterator<Schedule>}
+     */
+    findAllIterator<T>(options?: OptionsWithRql): FindAllIterator<Schedule<T>>;
+    /**
+     * ## Retrieve the first queried Schedule
+     *
+     * **Global Permissions:**
+     * - `VIEW_TASK_SCHEDULES` - Allows a user to view Schedules
+     *
+     * @param options {@link OptionsWithRql} - Add filters to the requested list
+     * @returns The first element of the queried Schedules {@link Schedule}
+     */
+    findFirst<T>(options?: OptionsWithRql): Promise<Schedule<T>>;
+}
+export interface ScheduleCreation<T = Record<string, any>> {
+    /** The period in seconds, for which the function defined will execute recurrently */
+    interval: number;
+    /** The functionName property serves as the unique identifier amongst all Functions */
+    functionName: string;
+    /** The data to be provided to the Function, the type may be user defined */
+    data?: T;
+    /** The priority of the schedule (Higher priorities shall execute first) */
+    priority?: number;
+    /** The timestamp at which the schedule will start executing */
+    startTimestamp?: Date;
+}
+export interface Schedule<T = Record<string, any>> extends ScheduleCreation<T> {
+    id: ObjectId;
+    /** The timestamp at which the schedule will start executing */
+    startTimestamp: Date;
+    /** The timestamp at which the schedule was last updated */
+    updateTimestamp: Date;
+    /** The timestamp at which the schedule was created */
+    creationTimestamp: Date;
+    /** The timestamp at which the schedule will next execute */
+    nextTimestamp: Date;
+}

package/build/types/services/tasks/tasks.d.ts

@@ -0,0 +1,5 @@
+import type { HttpInstance } from '../../types';
+import { HttpClient } from '../http-client';
+import type { TasksService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => TasksService;
+export default _default;

package/build/types/services/tasks/types.d.ts

@@ -0,0 +1,107 @@
+import { FindAllIterator } from '../../services/helpers';
+import type { AffectedRecords, ObjectId, OptionsBase, OptionsWithRql, PagedResult } from '../types';
+export * from './api/types';
+export * from './apiRequests/types';
+export * from './functions/types';
+export * from './logs/types';
+export * from './schedules/types';
+export declare enum TaskStatus {
+    NEW = "new",
+    IN_PROGRESS = "inProgress",
+    COMPLETE = "complete",
+    FAILED = "failed",
+    CANCELED = "canceled"
+}
+export interface Task<DataType = any> {
+    id?: ObjectId;
+    status?: TaskStatus;
+    statusChangedTimestamp?: Date;
+    /**
+     * AWS Lambda function name
+     */
+    functionName: string;
+    /**
+     * Data send to the function
+     */
+    data?: DataType;
+    startTimestamp?: Date;
+    tags?: Array<string>;
+    priority?: number;
+    creationTimestamp?: Date;
+    updateTimestamp?: Date;
+    /** The Extra Horizon document id for the application used to make the request */
+    createdByApplicationId?: ObjectId;
+    /** The Extra Horizon document id for the user who made the request */
+    createdByUserId?: ObjectId;
+}
+export declare type TaskInput = Pick<Task, 'functionName' | 'data' | 'startTimestamp' | 'priority' | 'tags'>;
+export interface TasksService {
+    /**
+     * View a list of tasks
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @returns PagedResult<Task>
+     */
+    find(options?: OptionsWithRql): Promise<PagedResult<Task>>;
+    /**
+     * Find By Id
+     * @param id the Id to search for
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findById(id: ObjectId, options?: OptionsWithRql): Promise<Task>;
+    /**
+     * Request a list of all tasks
+     *
+     * Do not pass in an rql with limit operator!
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns Task[]
+     */
+    findAll(options?: OptionsWithRql): Promise<Task[]>;
+    /**
+     * Request a list of all tasks
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TASKS` | `gobal` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns Task[]
+     */
+    findAllIterator(options?: OptionsWithRql): FindAllIterator<Task>;
+    /**
+     * Find First
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findFirst(options?: OptionsWithRql): Promise<Task>;
+    /**
+     * Create a task
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `CREATE_TASKS` | `gobal` | **Required** for this endpoint
+     * @param requestBody
+     * @returns Task Success
+     */
+    create(requestBody: TaskInput, options?: OptionsBase): Promise<Task>;
+    /**
+     * Cancel a task
+     *
+     * The targeted task **MUST** be in the `new` status.
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `CANCEL_TASKS` | `gobal` | **Required** for this endpoint
+     * @param taskId The id of the targeted task
+     * @returns AffectedRecords
+     * @throws {IllegalStateException}
+     * @throws {ResourceUnknownException}
+     */
+    cancel(taskId: ObjectId, options?: OptionsBase): Promise<AffectedRecords>;
+}

package/build/types/services/templates/index.d.ts

@@ -0,0 +1,3 @@
+import type { HttpInstance } from '../../types';
+import { TemplatesService } from './types';
+export declare const templatesService: (httpWithAuth: HttpInstance) => TemplatesService;

package/build/types/services/templates/templates.d.ts

@@ -0,0 +1,5 @@
+import type { HttpInstance } from '../../types';
+import { HttpClient } from '../http-client';
+import type { TemplatesService } from './types';
+declare const _default: (client: HttpClient, httpAuth: HttpInstance) => TemplatesService;
+export default _default;

package/build/types/services/templates/types.d.ts

@@ -0,0 +1,202 @@
+/// <reference types="node" />
+import { FindAllIterator } from '../../services/helpers';
+import { TypeConfiguration } from '../data/types';
+import { ObjectId, LanguageCode, TimeZone, PagedResult, AffectedRecords, OptionsWithRql, OptionsBase } from '../types';
+export interface TemplateOut {
+    id?: ObjectId;
+    name?: string;
+    description?: string;
+    schema?: TemplateObjectConfiguration;
+    fields?: Record<string, string>;
+    creationTimestamp?: Date;
+    updateTimestamp?: Date;
+}
+export interface TemplateIn {
+    name: string;
+    description: string;
+    schema: TemplateObjectConfiguration;
+    fields: Record<string, string>;
+}
+export interface TemplateObjectConfiguration {
+    type?: 'object';
+    options?: Array<ObjectOption>;
+    fields?: Record<string, TypeConfiguration>;
+}
+export declare type ObjectOption = ObjectMinBytesOption | ObjectMaxBytesOption;
+export interface ObjectMinBytesOption {
+    type?: ObjectMinBytesOptionType;
+    value: number;
+}
+export declare enum ObjectMinBytesOptionType {
+    MIN_BYTES = "min_bytes"
+}
+export interface ObjectMaxBytesOption {
+    type?: ObjectMaxBytesOptionType;
+    value: number;
+}
+export declare enum ObjectMaxBytesOptionType {
+    MAX_BYTES = "max_bytes"
+}
+export interface CreateFile {
+    /**
+     * If not present (or empty) we will first check the configured language in the users-service. If that is not present it will default to 'EN'
+     */
+    language?: LanguageCode;
+    /**
+     * If not present (or empty) we will first check the configured time_zone in the users-service. If that is not present it will default to 'Europe/Brussels'
+     */
+    timeZone?: TimeZone;
+    content: Record<string, any>;
+}
+export interface TemplatesService {
+    /**
+     * Perform a health check
+     * @returns {boolean} success
+     */
+    health(): Promise<boolean>;
+    /**
+     * Get all templates the service has to offer
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns PagedResult<TemplateOut>
+     */
+    find(options?: OptionsWithRql): Promise<PagedResult<TemplateOut>>;
+    /**
+     * Request a list of all templates
+     *
+     * Do not pass in an rql with limit operator!
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns TemplateOut[]
+     */
+    findAll(options?: OptionsWithRql): Promise<TemplateOut[]>;
+    /**
+     * Request a list of all templates
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `VIEW_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param rql Add filters to the requested list.
+     * @returns TemplateOut[]
+     */
+    findAllIterator(options?: OptionsWithRql): FindAllIterator<TemplateOut>;
+    /**
+     * Find By Id
+     * @param id the Id to search for
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findById(id: ObjectId, options?: OptionsWithRql): Promise<TemplateOut>;
+    /**
+     * Find By Name
+     * @param name the name to search for
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findByName(name: string, options?: OptionsWithRql): Promise<TemplateOut>;
+    /**
+     * Find First
+     * @param rql an optional rql string
+     * @returns the first element found
+     */
+    findFirst(options?: OptionsWithRql): Promise<TemplateOut>;
+    /**
+     * Create a new template
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `CREATE_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param requestBody TemplateIn
+     * @returns TemplateOut
+     */
+    create(requestBody: TemplateIn, options?: OptionsBase): Promise<TemplateOut>;
+    /**
+     * Update an existing template
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `UPDATE_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param templateId Id of the targeted template
+     * @param requestBody TemplateIn
+     * @returns TemplateOut
+     * @throws {ResourceUnknownError}
+     */
+    update(templateId: string, requestBody: TemplateIn, options?: OptionsBase): Promise<TemplateOut>;
+    /**
+     * Delete a template
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * `DELETE_TEMPLATES` | `global` | **Required** for this endpoint
+     * @param templateId Id of the targeted template
+     * @returns AffectedRecords
+     * @throws {ResourceUnknownError}
+     */
+    remove(templateId: string, options?: OptionsBase): Promise<AffectedRecords>;
+    /**
+     * Resolves a template and presents the result as a pdf file
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * none | | Everyone can use this endpoint
+     * @param templateId Id of the targeted template
+     * @param requestBody The file data
+     * @returns Buffer
+     * @throws {LocalizationKeyMissingError}
+     * @throws {TemplateFillingError}
+     * @throws {ResourceUnknownError}
+     */
+    resolveAsPdf(templateId: string, requestBody: CreateFile, options?: OptionsBase): Promise<Buffer>;
+    /**
+     * @deprecated
+     * Resolves a template and presents the result as a pdf file
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * none | | Everyone can use this endpoint
+     * @param templateId Id of the targeted template
+     * @param localizationCode Specifies the language the template must be resolved in
+     * @param requestBody The file data
+     * @returns Buffer
+     * @throws {LocalizationKeyMissingError}
+     * @throws {TemplateFillingError}
+     * @throws {ResourceUnknownError}
+     */
+    resolveAsPdfUsingCode(templateId: string, localizationCode: string, requestBody: CreateFile, options?: OptionsBase): Promise<Buffer>;
+    /**
+     * Resolves a template and presents the result as a json response
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * none | | Everyone can use this endpoint
+     * @param templateId Id of the targeted template
+     * @param requestBody CreateFile
+     * @returns Record<string, string>
+     * @throws {LocalizationKeyMissingError}
+     * @throws {TemplateFillingError}
+     * @throws {ResourceUnknownError}
+     */
+    resolveAsJson(templateId: string, requestBody: CreateFile, options?: OptionsBase): Promise<Record<string, string>>;
+    /**
+     * @deprecated
+     * Resolves a template and presents the result as a json response
+     *
+     * Permission | Scope | Effect
+     * - | - | -
+     * none | | Everyone can use this endpoint
+     * @param templateId Id of the targeted template
+     * @param localizationCode Specifies the language the template must be resolved in
+     * @param requestBody CreateFile
+     * @returns Record<string, string>
+     * @throws {LocalizationKeyMissingError}
+     * @throws {TemplateFillingError}
+     * @throws {ResourceUnknownError}
+     */
+    resolveAsJsonUsingCode(templateId: string, localizationCode: string, requestBody: CreateFile, options?: OptionsBase): Promise<Record<string, string>>;
+}

package/build/types/services/types.d.ts

@@ -0,0 +1,77 @@
+import { RQLString } from '../rql';
+export declare type LanguageCode = string;
+export declare type ObjectId = string;
+export interface Entity {
+    id: ObjectId;
+}
+export interface Timestamps {
+    updateTimestamp: Date;
+    creationTimestamp: Date;
+}
+export interface ErrorResponse {
+    code?: number;
+    name?: string;
+    message?: string;
+}
+export interface PagedResult<T> {
+    page: {
+        total: number;
+        offset: number;
+        limit: number;
+    };
+    data: T[];
+}
+export interface AffectedRecords {
+    affectedRecords: number;
+}
+export interface ResultResponse {
+    status: number;
+}
+export declare enum Results {
+    Success = 200
+}
+/**
+ * Supported timezones from [Java.time.zoneId](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html#of-java.lang.String-)
+ */
+export declare type TimeZone = string;
+export declare type MailAddress = string;
+export declare type MailAddressList = MailAddress[];
+export interface MailRecipients {
+    to: MailAddressList;
+    cc?: MailAddressList;
+    bcc?: MailAddressList;
+}
+export declare type Headers = Record<string, string>;
+export declare type OptionsBase = {
+    /** Added to all HTTP verbs */
+    headers?: Headers;
+    /** Only passed to the GET requests. Will retry 4 times on 500 errors */
+    shouldRetry?: boolean;
+    /**
+     * @deprecated this property is only meant to be used for backwards compatibility when upgrading to v8.0.0.
+     *
+     * Key names that are not chosen by Extra Horizon where also affected by the data normalization before v8.0.0.
+     * They were converted from camel case to snake case before sending the request and the other way around before
+     * providing the response.
+     *
+     * Also fields ending with the name timestamp not chosen by extra horizon in custom properties where automatically
+     * converted to dates. Even though they could be just booleans, strings or numbers. Dates provided in such fields will
+     * now be converted to strings while all other types will stay as they are.
+     *
+     * To enable this behaviour again, set to true.
+     */
+    normalizeCustomData?: boolean;
+};
+export declare type OptionsWithRql = OptionsBase & {
+    rql?: RQLString;
+};
+export interface FileUploadOptions extends OptionsBase {
+    onUploadProgress?: (progress: {
+        loaded: number;
+        total: number;
+    }) => void;
+}
+export declare type PagedResultWithPager<T> = PagedResult<T> & {
+    previous: () => Promise<PagedResultWithPager<T>>;
+    next: () => Promise<PagedResultWithPager<T>>;
+};

package/build/types/services/users/activationRequests/index.d.ts

@@ -0,0 +1,4 @@
+import { HttpInstance } from '../../../types';
+import { HttpClient } from '../../http-client';
+import { ActivationRequestsService } from './types';
+export declare const activationRequestsService: (client: HttpClient, httpWithAuth: HttpInstance) => ActivationRequestsService;