@innobrain/onoffice-adapter-js 0.1.0

package/dist/constants.d.ts

@@ -0,0 +1,55 @@
+export declare const OnOfficeAction: {
+    readonly Read: "urn:onoffice-de-ns:smart:2.5:smartml:action:read";
+    readonly Create: "urn:onoffice-de-ns:smart:2.5:smartml:action:create";
+    readonly Modify: "urn:onoffice-de-ns:smart:2.5:smartml:action:modify";
+    readonly Get: "urn:onoffice-de-ns:smart:2.5:smartml:action:get";
+    readonly Do: "urn:onoffice-de-ns:smart:2.5:smartml:action:do";
+    readonly Delete: "urn:onoffice-de-ns:smart:2.5:smartml:action:delete";
+};
+export type OnOfficeAction = (typeof OnOfficeAction)[keyof typeof OnOfficeAction];
+export declare const OnOfficeResourceType: {
+    readonly Address: "address";
+    readonly Estate: "estate";
+    readonly EstatePictures: "estatepictures";
+    readonly Fields: "fields";
+    readonly Filters: "filters";
+    readonly File: "file";
+    readonly IdsFromRelation: "idsfromrelation";
+    readonly User: "user";
+    readonly Users: "users";
+    readonly UserPhoto: "userphoto";
+    readonly UnlockProvider: "unlockProvider";
+    readonly MarketplaceInvoiceRecipient: "getMarketplaceInvoiceRecipient";
+    readonly MarketplaceCancelAbo: "marketplaceCancelAbo";
+    readonly SubsequentPaymentLink: "subsequentPaymentLink";
+    readonly TransactionRefund: "transactionRefund";
+    readonly ExecuteMarketplaceWebhooks: "executeMarketplaceWebhooks";
+    readonly Regions: "regions";
+    readonly UploadFile: "uploadfile";
+    readonly FileRelation: "fileRelation";
+    readonly Impressum: "impressum";
+    readonly Activity: "agentslog";
+    readonly GetSearchCriteria: "searchcriterias";
+    readonly SearchCriteria: "searchcriteria";
+    readonly SearchCriteriaFields: "searchCriteriaFields";
+    readonly ActionTypes: "actionkindtypes";
+    readonly Relation: "relation";
+    readonly Search: "search";
+    readonly MultiselectKey: "multiselectkey";
+    readonly MacroResolve: "macroresolve";
+    readonly Log: "log";
+    readonly CheckUserRecordsRight: "checkuserrecordsright";
+    readonly GetLink: "getlink";
+    readonly RecordsLastSeen: "recordsLastSeen";
+};
+export type OnOfficeResourceType = (typeof OnOfficeResourceType)[keyof typeof OnOfficeResourceType];
+export declare const ParameterKeys: {
+    readonly data: "data";
+    readonly listLimit: "listlimit";
+    readonly listOffset: "listoffset";
+    readonly filter: "filter";
+    readonly sortBy: "sortby";
+    readonly sortOrder: "sortorder";
+    readonly extendedClaim: "extendedclaim";
+};
+export declare const MAX_PAGE_SIZE = 500;

package/dist/constants.js

@@ -0,0 +1,53 @@
+export const OnOfficeAction = {
+    Read: "urn:onoffice-de-ns:smart:2.5:smartml:action:read",
+    Create: "urn:onoffice-de-ns:smart:2.5:smartml:action:create",
+    Modify: "urn:onoffice-de-ns:smart:2.5:smartml:action:modify",
+    Get: "urn:onoffice-de-ns:smart:2.5:smartml:action:get",
+    Do: "urn:onoffice-de-ns:smart:2.5:smartml:action:do",
+    Delete: "urn:onoffice-de-ns:smart:2.5:smartml:action:delete",
+};
+export const OnOfficeResourceType = {
+    Address: "address",
+    Estate: "estate",
+    EstatePictures: "estatepictures",
+    Fields: "fields",
+    Filters: "filters",
+    File: "file",
+    IdsFromRelation: "idsfromrelation",
+    User: "user",
+    Users: "users",
+    UserPhoto: "userphoto",
+    UnlockProvider: "unlockProvider",
+    MarketplaceInvoiceRecipient: "getMarketplaceInvoiceRecipient",
+    MarketplaceCancelAbo: "marketplaceCancelAbo",
+    SubsequentPaymentLink: "subsequentPaymentLink",
+    TransactionRefund: "transactionRefund",
+    ExecuteMarketplaceWebhooks: "executeMarketplaceWebhooks",
+    Regions: "regions",
+    UploadFile: "uploadfile",
+    FileRelation: "fileRelation",
+    Impressum: "impressum",
+    Activity: "agentslog",
+    GetSearchCriteria: "searchcriterias",
+    SearchCriteria: "searchcriteria",
+    SearchCriteriaFields: "searchCriteriaFields",
+    ActionTypes: "actionkindtypes",
+    Relation: "relation",
+    Search: "search",
+    MultiselectKey: "multiselectkey",
+    MacroResolve: "macroresolve",
+    Log: "log",
+    CheckUserRecordsRight: "checkuserrecordsright",
+    GetLink: "getlink",
+    RecordsLastSeen: "recordsLastSeen",
+};
+export const ParameterKeys = {
+    data: "data",
+    listLimit: "listlimit",
+    listOffset: "listoffset",
+    filter: "filter",
+    sortBy: "sortby",
+    sortOrder: "sortorder",
+    extendedClaim: "extendedclaim",
+};
+export const MAX_PAGE_SIZE = 500;

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class OnOfficeError extends Error {
+    readonly code: number;
+    readonly isResponseError: boolean;
+    readonly response?: unknown;
+    constructor(message: string, code: number, options?: {
+        isResponseError?: boolean;
+        response?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,9 @@
+export class OnOfficeError extends Error {
+    constructor(message, code, options) {
+        super(message);
+        this.name = "OnOfficeError";
+        this.code = code;
+        this.isResponseError = options?.isResponseError ?? false;
+        this.response = options?.response;
+    }
+}

package/dist/fields.d.ts

@@ -0,0 +1,8 @@
+import { OnOfficeQueryBuilder, OnOfficeClient } from "./client";
+export declare class FieldQueryBuilder<TRecord = unknown> extends OnOfficeQueryBuilder<TRecord> {
+    private modules;
+    constructor(client: OnOfficeClient);
+    withModules(modules: string[] | string): this;
+    get(): Promise<TRecord[]>;
+    first(): Promise<TRecord | null>;
+}

package/dist/fields.js

@@ -0,0 +1,31 @@
+import { OnOfficeAction, OnOfficeResourceType } from "./constants";
+import { OnOfficeQueryBuilder } from "./client";
+import { extractFirstRecord } from "./utils";
+export class FieldQueryBuilder extends OnOfficeQueryBuilder {
+    constructor(client) {
+        super(client, OnOfficeResourceType.Fields);
+        this.modules = [];
+    }
+    withModules(modules) {
+        const next = Array.isArray(modules) ? modules : [modules];
+        this.modules = [...this.modules, ...next];
+        return this;
+    }
+    async get() {
+        return this.client.requestAll(OnOfficeAction.Get, this.resourceType, {
+            parameters: {
+                modules: this.modules,
+                ...this.customParameters,
+            },
+        });
+    }
+    async first() {
+        const response = await this.client.request(OnOfficeAction.Get, this.resourceType, {
+            parameters: {
+                modules: this.modules,
+                ...this.customParameters,
+            },
+        });
+        return extractFirstRecord(response);
+    }
+}

package/dist/files.d.ts

@@ -0,0 +1,14 @@
+import { OnOfficeClient } from "./client";
+export declare class FileUploadQueryBuilder {
+    private readonly client;
+    private uploadBlockSize;
+    private customParameters;
+    constructor(client: OnOfficeClient);
+    uploadInBlocks(blockSize?: number): this;
+    parameter(key: string, value: unknown): this;
+    parameters(parameters: Record<string, unknown>): this;
+    save(fileContent: string): Promise<string>;
+    link(tmpUploadId: string, data?: Record<string, unknown>): Promise<unknown>;
+    saveAndLink(fileContent: string, data?: Record<string, unknown>): Promise<unknown>;
+    private splitFileContent;
+}

package/dist/files.js

@@ -0,0 +1,73 @@
+import { OnOfficeAction, OnOfficeResourceType, ParameterKeys } from "./constants";
+import { extractFirstRecord } from "./utils";
+export class FileUploadQueryBuilder {
+    constructor(client) {
+        this.client = client;
+        this.uploadBlockSize = 0;
+        this.customParameters = {};
+    }
+    uploadInBlocks(blockSize = 20480) {
+        this.uploadBlockSize = Math.max(1, blockSize);
+        return this;
+    }
+    parameter(key, value) {
+        this.customParameters[key] = value;
+        return this;
+    }
+    parameters(parameters) {
+        this.customParameters = {
+            ...this.customParameters,
+            ...parameters,
+        };
+        return this;
+    }
+    async save(fileContent) {
+        const blocks = this.splitFileContent(fileContent);
+        let tmpUploadId = "";
+        for (const block of blocks) {
+            const parameters = {
+                [ParameterKeys.data]: block,
+                ...this.customParameters,
+            };
+            if (tmpUploadId) {
+                parameters.tmpUploadId = tmpUploadId;
+            }
+            const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.UploadFile, {
+                parameters,
+            });
+            const record = response.response?.results?.[0]?.data?.records?.[0];
+            tmpUploadId = record?.elements?.tmpUploadId ?? tmpUploadId;
+        }
+        if (!tmpUploadId) {
+            throw new Error("Upload did not return tmpUploadId.");
+        }
+        return tmpUploadId;
+    }
+    async link(tmpUploadId, data = {}) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.UploadFile, {
+            parameters: {
+                ...data,
+                tmpUploadId,
+                ...this.customParameters,
+            },
+        });
+        return extractFirstRecord(response);
+    }
+    async saveAndLink(fileContent, data = {}) {
+        const tmpUploadId = await this.save(fileContent);
+        return this.link(tmpUploadId, data);
+    }
+    splitFileContent(fileContent) {
+        if (!fileContent) {
+            return [fileContent];
+        }
+        if (this.uploadBlockSize <= 0) {
+            return [fileContent];
+        }
+        const chunks = [];
+        for (let index = 0; index < fileContent.length; index += this.uploadBlockSize) {
+            chunks.push(fileContent.slice(index, index + this.uploadBlockSize));
+        }
+        return chunks;
+    }
+}

package/dist/hmac.d.ts

@@ -0,0 +1 @@
+export declare const createHmacSignature: (message: string, secret: string) => Promise<string>;

package/dist/hmac.js

@@ -0,0 +1,27 @@
+const base64FromArrayBuffer = (buffer) => {
+    const bytes = new Uint8Array(buffer);
+    if (typeof btoa === "function") {
+        let binary = "";
+        bytes.forEach((byte) => {
+            binary += String.fromCharCode(byte);
+        });
+        return btoa(binary);
+    }
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    throw new Error("No base64 encoder available");
+};
+export const createHmacSignature = async (message, secret) => {
+    if (globalThis.crypto?.subtle) {
+        const encoder = new TextEncoder();
+        const key = await globalThis.crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+        const signature = await globalThis.crypto.subtle.sign("HMAC", key, encoder.encode(message));
+        return base64FromArrayBuffer(signature);
+    }
+    const nodeCrypto = await import("crypto").catch(() => null);
+    if (nodeCrypto?.createHmac) {
+        return nodeCrypto.createHmac("sha256", secret).update(message).digest("base64");
+    }
+    throw new Error("No crypto implementation available for HMAC");
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { MAX_PAGE_SIZE, OnOfficeAction, OnOfficeResourceType, ParameterKeys } from "./constants";
+export { OnOfficeClient, OnOfficeQueryBuilder } from "./client";
+export { ActivityQueryBuilder } from "./activity";
+export { FieldQueryBuilder } from "./fields";
+export { FileUploadQueryBuilder } from "./files";
+export { SearchCriteriaFieldQueryBuilder, SearchCriteriaQueryBuilder, SearchCriteriaSearchQueryBuilder, } from "./search-criteria";
+export { ActionQueryBuilder, ImprintQueryBuilder, RegionQueryBuilder, UserQueryBuilder, } from "./settings";
+export { OnOfficeError } from "./errors";
+export { createHmacSignature } from "./hmac";
+export { compactParameters, extractRecords, extractFirstRecord } from "./utils";
+export { ActivityRepository, AddressRepository, EstateRepository, FieldRepository, FileRepository, MarketplaceRepository, OnOfficeRepository, RawRepository, SearchCriteriaRepository, SettingRepository, createRepositories, } from "./repositories";
+export type { Repositories } from "./repositories";
+export type { AddressFileOptions, EstateFileOptions, MarketplaceCancelSubscriptionParams, MarketplaceExecuteWebhooksParams, MarketplaceInvoiceRecipientParams, MarketplaceRefundTransactionParams, MarketplaceSubsequentPaymentParams, MarketplaceUnlockProviderParams, MarketplaceWebhookModule, } from "./repositories";
+export type { DebugRequestInfo, DebugResponseInfo, Fetcher, FilterOperator, OnOfficeApiResponse, OnOfficeClientConfig, OnOfficeRequestOptions, PaginationOptions, RetryOptions, } from "./types";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { MAX_PAGE_SIZE, OnOfficeAction, OnOfficeResourceType, ParameterKeys } from "./constants";
+export { OnOfficeClient, OnOfficeQueryBuilder } from "./client";
+export { ActivityQueryBuilder } from "./activity";
+export { FieldQueryBuilder } from "./fields";
+export { FileUploadQueryBuilder } from "./files";
+export { SearchCriteriaFieldQueryBuilder, SearchCriteriaQueryBuilder, SearchCriteriaSearchQueryBuilder, } from "./search-criteria";
+export { ActionQueryBuilder, ImprintQueryBuilder, RegionQueryBuilder, UserQueryBuilder, } from "./settings";
+export { OnOfficeError } from "./errors";
+export { createHmacSignature } from "./hmac";
+export { compactParameters, extractRecords, extractFirstRecord } from "./utils";
+export { ActivityRepository, AddressRepository, EstateRepository, FieldRepository, FileRepository, MarketplaceRepository, OnOfficeRepository, RawRepository, SearchCriteriaRepository, SettingRepository, createRepositories, } from "./repositories";

package/dist/repositories.d.ts

@@ -0,0 +1,120 @@
+import { OnOfficeQueryBuilder, OnOfficeClient } from "./client";
+import { OnOfficeResourceType } from "./constants";
+import { ActivityQueryBuilder } from "./activity";
+import { FieldQueryBuilder } from "./fields";
+import { FileUploadQueryBuilder } from "./files";
+import { SearchCriteriaFieldQueryBuilder, SearchCriteriaQueryBuilder, SearchCriteriaSearchQueryBuilder } from "./search-criteria";
+import { ActionQueryBuilder, ImprintQueryBuilder, RegionQueryBuilder, UserQueryBuilder } from "./settings";
+export declare class OnOfficeRepository {
+    protected readonly client: OnOfficeClient;
+    protected readonly resourceType?: OnOfficeResourceType | undefined;
+    constructor(client: OnOfficeClient, resourceType?: OnOfficeResourceType | undefined);
+    query<TRecord = unknown>(): OnOfficeQueryBuilder<TRecord>;
+}
+export declare class RawRepository {
+    protected readonly client: OnOfficeClient;
+    constructor(client: OnOfficeClient);
+    query<TRecord = unknown>(resourceType: string): OnOfficeQueryBuilder<TRecord>;
+    request(actionId: Parameters<OnOfficeClient["request"]>[0], resourceType: string, options?: Parameters<OnOfficeClient["request"]>[2]): Promise<import("./types").OnOfficeApiResponse<unknown>>;
+    requestAll(actionId: Parameters<OnOfficeClient["requestAll"]>[0], resourceType: string, options: Parameters<OnOfficeClient["requestAll"]>[2], pagination?: Parameters<OnOfficeClient["requestAll"]>[3]): Promise<unknown[]>;
+}
+export type MarketplaceWebhookModule = "estate" | "address" | "task" | "calendar";
+export interface MarketplaceUnlockProviderParams {
+    parameterCacheId: string[] | string;
+    isRegularCustomer?: boolean;
+    extendedClaim?: string;
+}
+export interface MarketplaceInvoiceRecipientParams {
+    transactionId: number | string;
+    userId: number | string;
+    extendedClaim?: string;
+}
+export interface MarketplaceCancelSubscriptionParams {
+    aboId: string | number;
+    cancelationDate?: string;
+    extendedClaim?: string;
+}
+export interface MarketplaceSubsequentPaymentParams {
+    transactionId: number | string;
+    priceNet: string;
+    description: string;
+    sendMailToCustomer?: boolean;
+}
+export interface MarketplaceRefundTransactionParams {
+    transactionId: number | string;
+}
+export interface MarketplaceExecuteWebhooksParams {
+    module: MarketplaceWebhookModule;
+    extendedClaim?: string;
+}
+export declare class EstateRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+}
+export declare class AddressRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+}
+export declare class ActivityRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+    query<TRecord = unknown>(): ActivityQueryBuilder<TRecord>;
+}
+export declare class FieldRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+    query<TRecord = unknown>(): FieldQueryBuilder<TRecord>;
+}
+export declare class SearchCriteriaRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+    query<TRecord = unknown>(): SearchCriteriaQueryBuilder<TRecord>;
+    fields<TRecord = unknown>(): SearchCriteriaFieldQueryBuilder<TRecord>;
+    search<TRecord = unknown>(): SearchCriteriaSearchQueryBuilder<TRecord>;
+    records<TRecord = unknown>(): OnOfficeQueryBuilder<TRecord>;
+}
+export interface AddressFileOptions {
+    fileId?: number;
+    listLimit?: number;
+    listOffset?: number;
+}
+export interface EstateFileOptions {
+    fileId?: number;
+    documentAttribute?: string;
+    includeImageUrl?: "small" | "medium" | "original";
+    showIsPublishedOnHomepage?: boolean;
+    showPublicationStatus?: boolean;
+    listLimit?: number;
+    listOffset?: number;
+}
+export declare class FileRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+    upload(): FileUploadQueryBuilder;
+    addressFiles<TRecord = unknown>(addressId: number, options?: AddressFileOptions): Promise<TRecord[]>;
+    estateFiles<TRecord = unknown>(estateId: number, options?: EstateFileOptions): Promise<TRecord[]>;
+    private fetchFiles;
+}
+export declare class MarketplaceRepository {
+    private readonly client;
+    constructor(client: OnOfficeClient);
+    unlockProvider<TRecord = unknown>(params: MarketplaceUnlockProviderParams): Promise<TRecord[]>;
+    invoiceRecipient<TRecord = unknown>(params: MarketplaceInvoiceRecipientParams): Promise<TRecord[]>;
+    cancelSubscription<TRecord = unknown>(params: MarketplaceCancelSubscriptionParams): Promise<TRecord[]>;
+    generateSubsequentPaymentLink<TRecord = unknown>(params: MarketplaceSubsequentPaymentParams): Promise<TRecord[]>;
+    refundTransaction<TRecord = unknown>(params: MarketplaceRefundTransactionParams): Promise<TRecord[]>;
+    executeWebhooks<TRecord = unknown>(recordId: number | string, params: MarketplaceExecuteWebhooksParams): Promise<TRecord[]>;
+}
+export declare class SettingRepository extends OnOfficeRepository {
+    constructor(client: OnOfficeClient);
+    users<TRecord = unknown>(): UserQueryBuilder<TRecord>;
+    regions<TRecord = unknown>(): RegionQueryBuilder<TRecord>;
+    imprint<TRecord = unknown>(): ImprintQueryBuilder<TRecord>;
+    actions<TRecord = unknown>(): ActionQueryBuilder<TRecord>;
+}
+export interface Repositories {
+    raw: RawRepository;
+    estate: EstateRepository;
+    address: AddressRepository;
+    activity: ActivityRepository;
+    fields: FieldRepository;
+    searchCriteria: SearchCriteriaRepository;
+    file: FileRepository;
+    marketplace: MarketplaceRepository;
+    settings: SettingRepository;
+}
+export declare function createRepositories(client: OnOfficeClient): Repositories;

package/dist/repositories.js

@@ -0,0 +1,211 @@
+import { OnOfficeAction, OnOfficeResourceType, ParameterKeys } from "./constants";
+import { ActivityQueryBuilder } from "./activity";
+import { FieldQueryBuilder } from "./fields";
+import { FileUploadQueryBuilder } from "./files";
+import { SearchCriteriaFieldQueryBuilder, SearchCriteriaQueryBuilder, SearchCriteriaSearchQueryBuilder, } from "./search-criteria";
+import { ActionQueryBuilder, ImprintQueryBuilder, RegionQueryBuilder, UserQueryBuilder, } from "./settings";
+import { compactParameters, extractRecords } from "./utils";
+export class OnOfficeRepository {
+    constructor(client, resourceType) {
+        this.client = client;
+        this.resourceType = resourceType;
+    }
+    query() {
+        if (!this.resourceType) {
+            throw new Error("Repository resource type is not configured.");
+        }
+        return this.client.resource(this.resourceType);
+    }
+}
+export class RawRepository {
+    constructor(client) {
+        this.client = client;
+    }
+    query(resourceType) {
+        return this.client.resource(resourceType);
+    }
+    request(actionId, resourceType, options) {
+        return this.client.request(actionId, resourceType, options);
+    }
+    requestAll(actionId, resourceType, options, pagination) {
+        return this.client.requestAll(actionId, resourceType, options, pagination);
+    }
+}
+export class EstateRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client, OnOfficeResourceType.Estate);
+    }
+}
+export class AddressRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client, OnOfficeResourceType.Address);
+    }
+}
+export class ActivityRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client, OnOfficeResourceType.Activity);
+    }
+    query() {
+        return new ActivityQueryBuilder(this.client);
+    }
+}
+export class FieldRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client, OnOfficeResourceType.Fields);
+    }
+    query() {
+        return new FieldQueryBuilder(this.client);
+    }
+}
+export class SearchCriteriaRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client);
+    }
+    query() {
+        return new SearchCriteriaQueryBuilder(this.client);
+    }
+    fields() {
+        return new SearchCriteriaFieldQueryBuilder(this.client);
+    }
+    search() {
+        return new SearchCriteriaSearchQueryBuilder(this.client);
+    }
+    records() {
+        return this.client.resource(OnOfficeResourceType.SearchCriteria);
+    }
+}
+export class FileRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client, OnOfficeResourceType.File);
+    }
+    upload() {
+        return new FileUploadQueryBuilder(this.client);
+    }
+    addressFiles(addressId, options = {}) {
+        return this.fetchFiles(OnOfficeResourceType.Address, {
+            addressid: addressId,
+            fileid: options.fileId,
+        }, {
+            listLimit: options.listLimit,
+            listOffset: options.listOffset,
+        });
+    }
+    estateFiles(estateId, options = {}) {
+        return this.fetchFiles(OnOfficeResourceType.Estate, {
+            estateid: estateId,
+            fileid: options.fileId,
+            documentAttribute: options.documentAttribute,
+            includeImageUrl: options.includeImageUrl,
+            showispublishedonhomepage: options.showIsPublishedOnHomepage,
+            showpublicationstatus: options.showPublicationStatus,
+        }, {
+            listLimit: options.listLimit,
+            listOffset: options.listOffset,
+        });
+    }
+    fetchFiles(resourceId, options, paginationOptions = {}) {
+        const parameters = compactParameters(options);
+        return this.client.requestAll(OnOfficeAction.Get, OnOfficeResourceType.File, {
+            resourceId,
+            parameters,
+        }, {
+            pageSize: paginationOptions.listLimit,
+            offset: paginationOptions.listOffset,
+            limit: paginationOptions.listLimit,
+        });
+    }
+}
+export class MarketplaceRepository {
+    constructor(client) {
+        this.client = client;
+    }
+    async unlockProvider(params) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.UnlockProvider, {
+            parameters: compactParameters({
+                parameterCacheId: params.parameterCacheId,
+                isRegularCustomer: params.isRegularCustomer,
+                [ParameterKeys.extendedClaim]: params.extendedClaim,
+            }),
+        });
+        return extractRecords(response);
+    }
+    async invoiceRecipient(params) {
+        const response = await this.client.request(OnOfficeAction.Get, OnOfficeResourceType.MarketplaceInvoiceRecipient, {
+            parameters: compactParameters({
+                transactionid: params.transactionId,
+                userid: params.userId,
+                [ParameterKeys.extendedClaim]: params.extendedClaim,
+            }),
+        });
+        return extractRecords(response);
+    }
+    async cancelSubscription(params) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.MarketplaceCancelAbo, {
+            parameters: compactParameters({
+                aboid: params.aboId,
+                cancelationDate: params.cancelationDate,
+                [ParameterKeys.extendedClaim]: params.extendedClaim,
+            }),
+        });
+        return extractRecords(response);
+    }
+    async generateSubsequentPaymentLink(params) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.SubsequentPaymentLink, {
+            parameters: compactParameters({
+                transactionid: params.transactionId,
+                priceNet: params.priceNet,
+                description: params.description,
+                sendMailToCustomer: params.sendMailToCustomer,
+            }),
+        });
+        return extractRecords(response);
+    }
+    async refundTransaction(params) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.TransactionRefund, {
+            parameters: compactParameters({
+                transactionid: params.transactionId,
+            }),
+        });
+        return extractRecords(response);
+    }
+    async executeWebhooks(recordId, params) {
+        const response = await this.client.request(OnOfficeAction.Do, OnOfficeResourceType.ExecuteMarketplaceWebhooks, {
+            resourceId: recordId,
+            parameters: compactParameters({
+                module: params.module,
+                [ParameterKeys.extendedClaim]: params.extendedClaim,
+            }),
+        });
+        return extractRecords(response);
+    }
+}
+export class SettingRepository extends OnOfficeRepository {
+    constructor(client) {
+        super(client);
+    }
+    users() {
+        return new UserQueryBuilder(this.client);
+    }
+    regions() {
+        return new RegionQueryBuilder(this.client);
+    }
+    imprint() {
+        return new ImprintQueryBuilder(this.client);
+    }
+    actions() {
+        return new ActionQueryBuilder(this.client);
+    }
+}
+export function createRepositories(client) {
+    return {
+        raw: new RawRepository(client),
+        estate: new EstateRepository(client),
+        address: new AddressRepository(client),
+        activity: new ActivityRepository(client),
+        fields: new FieldRepository(client),
+        searchCriteria: new SearchCriteriaRepository(client),
+        file: new FileRepository(client),
+        marketplace: new MarketplaceRepository(client),
+        settings: new SettingRepository(client),
+    };
+}