@redonvn/redai-backend-api-sdk 0.1.17 → 0.1.20

package/dist/generated/dynamic-table/services/row-color.service.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowColorService = void 0;
+class RowColorService {
+    constructor(client) {
+        this.client = client;
+    }
+    async createRowColorCondition(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color-conditions`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteRowColorCondition(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color-conditions/${encodeURIComponent(String(params.id))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateRowColorCondition(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color-conditions/${encodeURIComponent(String(params.id))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async updateRowColorMode(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color-select`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async clearRowColor(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getRowColor(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/row-color`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.RowColorService = RowColorService;

package/dist/generated/dynamic-table/services/sorts.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateSortParams, DeleteSortParams, GetSortParams, ListSortsParams, ReorderSortsParams, SortResponseDto, UpdateSortParams } from '../types';
+export declare class SortsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteSort(params: DeleteSortParams): Promise<ApiResponseDto<void>>;
+    getSort(params: GetSortParams): Promise<ApiResponseDto<SortResponseDto>>;
+    updateSort(params: UpdateSortParams): Promise<ApiResponseDto<SortResponseDto>>;
+    listSorts(params: ListSortsParams): Promise<ApiResponseDto<SortResponseDto[]>>;
+    createSort(params: CreateSortParams): Promise<ApiResponseDto<SortResponseDto>>;
+    reorderSorts(params: ReorderSortsParams): Promise<ApiResponseDto<null>>;
+}

package/dist/generated/dynamic-table/services/sorts.service.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortsService = void 0;
+class SortsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteSort(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/sorts/${encodeURIComponent(String(params.sortId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getSort(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/sorts/${encodeURIComponent(String(params.sortId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateSort(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/sorts/${encodeURIComponent(String(params.sortId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listSorts(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/sorts`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createSort(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/sorts`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async reorderSorts(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/sorts/reorder`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.SortsService = SortsService;

package/dist/generated/dynamic-table/services/sources.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateSourceParams, DeleteSourceParams, GetSourceParams, ListSourcesParams, PagedResponse, SourceResponseDto, UpdateSourceParams } from '../types';
+export declare class SourcesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listSources(params: ListSourcesParams): Promise<ApiResponseDto<PagedResponse<SourceResponseDto>>>;
+    createSource(params: CreateSourceParams): Promise<ApiResponseDto<SourceResponseDto>>;
+    deleteSource(params: DeleteSourceParams): Promise<ApiResponseDto<SourceResponseDto>>;
+    getSource(params: GetSourceParams): Promise<ApiResponseDto<SourceResponseDto>>;
+    updateSource(params: UpdateSourceParams): Promise<ApiResponseDto<SourceResponseDto>>;
+}

package/dist/generated/dynamic-table/services/sources.service.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourcesService = void 0;
+class SourcesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listSources(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/sources`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createSource(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/sources`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteSource(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/sources/${encodeURIComponent(String(params.sourceId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getSource(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/sources/${encodeURIComponent(String(params.sourceId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateSource(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/sources/${encodeURIComponent(String(params.sourceId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.SourcesService = SourcesService;

package/dist/generated/dynamic-table/services/tables.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateTableParams, DeleteTableParams, GetTableParams, ListTablesParams, PagedResponse, ReorderTablesParams, TableResponseDto, UpdateTableParams } from '../types';
+export declare class TablesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listTables(params?: ListTablesParams): Promise<ApiResponseDto<PagedResponse<TableResponseDto>>>;
+    createTable(params: CreateTableParams): Promise<ApiResponseDto<TableResponseDto>>;
+    deleteTable(params: DeleteTableParams): Promise<ApiResponseDto<null>>;
+    getTable(params: GetTableParams): Promise<ApiResponseDto<TableResponseDto>>;
+    updateTable(params: UpdateTableParams): Promise<ApiResponseDto<TableResponseDto>>;
+    reorderTables(params: ReorderTablesParams): Promise<ApiResponseDto<null>>;
+}

package/dist/generated/dynamic-table/services/tables.service.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablesService = void 0;
+class TablesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listTables(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/tables`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createTable(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteTable(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getTable(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateTable(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async reorderTables(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/reorder`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.TablesService = TablesService;

package/dist/generated/dynamic-table/services/user-ui-preferences.service.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, GetMeUiPreferencesParams, GetUserUiPreferencesResponseDto, UpdateMeUiPreferencesParams } from '../types';
+export declare class UserUiPreferencesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getMeUiPreferences(params?: GetMeUiPreferencesParams): Promise<ApiResponseDto<GetUserUiPreferencesResponseDto>>;
+    updateMeUiPreferences(params: UpdateMeUiPreferencesParams): Promise<ApiResponseDto<GetUserUiPreferencesResponseDto>>;
+}

package/dist/generated/dynamic-table/services/user-ui-preferences.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUiPreferencesService = void 0;
+class UserUiPreferencesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getMeUiPreferences(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/me/ui-preferences`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateMeUiPreferences(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/me/ui-preferences`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.UserUiPreferencesService = UserUiPreferencesService;

package/dist/generated/dynamic-table/services/utils.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, EnumsParams, HealthParams, PermissionsParams, VersionParams } from '../types';
+export declare class UtilsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    enums(params?: EnumsParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    health(params?: HealthParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    permissions(params?: PermissionsParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    version(params?: VersionParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+}

package/dist/generated/dynamic-table/services/utils.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtilsService = void 0;
+class UtilsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async enums(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/utils/enums`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async health(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/utils/health`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async permissions(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/utils/me/permissions`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async version(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/utils/version`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.UtilsService = UtilsService;

package/dist/generated/dynamic-table/services/view-columns.service.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, BulkUpdateViewColumnsParams, CreateViewColumnParams, ListGridColumnsParams, ListViewColumnsParams, UpdateFormColumnParams, UpdateGridColumnParams, UpdateViewColumnParams, ViewColumnResponseDto } from '../types';
+export declare class ViewColumnsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    updateFormColumn(params: UpdateFormColumnParams): Promise<ApiResponseDto<ViewColumnResponseDto>>;
+    updateGridColumn(params: UpdateGridColumnParams): Promise<ApiResponseDto<ViewColumnResponseDto>>;
+    listGridColumns(params: ListGridColumnsParams): Promise<ApiResponseDto<ViewColumnResponseDto[]>>;
+    listViewColumns(params: ListViewColumnsParams): Promise<ApiResponseDto<ViewColumnResponseDto[]>>;
+    bulkUpdateViewColumns(params: BulkUpdateViewColumnsParams): Promise<ApiResponseDto<null>>;
+    createViewColumn(params: CreateViewColumnParams): Promise<ApiResponseDto<ViewColumnResponseDto>>;
+    updateViewColumn(params: UpdateViewColumnParams): Promise<ApiResponseDto<ViewColumnResponseDto>>;
+}

package/dist/generated/dynamic-table/services/view-columns.service.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewColumnsService = void 0;
+class ViewColumnsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async updateFormColumn(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/form-columns/${encodeURIComponent(String(params.formViewColumnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async updateGridColumn(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/grid-columns/${encodeURIComponent(String(params.gridViewColumnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listGridColumns(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/grids/${encodeURIComponent(String(params.gridViewId))}/grid-columns`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async listViewColumns(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/columns`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async bulkUpdateViewColumns(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/columns`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async createViewColumn(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/columns`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async updateViewColumn(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.ViewColumnsService = ViewColumnsService;

package/dist/generated/dynamic-table/services/views.service.d.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateViewParams, DeleteViewParams, DuplicateViewParams, GetViewParams, HideViewParams, ListViewsParams, SetDefaultViewParams, ShowViewParams, UpdateViewParams, ViewResponseDto } from '../types';
+export declare class ViewsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listViews(params: ListViewsParams): Promise<ApiResponseDto<ViewResponseDto[]>>;
+    createView(params: CreateViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+    deleteView(params: DeleteViewParams): Promise<ApiResponseDto<void>>;
+    getView(params: GetViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+    updateView(params: UpdateViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+    setDefaultView(params: SetDefaultViewParams): Promise<ApiResponseDto<null>>;
+    duplicateView(params: DuplicateViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+    hideView(params: HideViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+    showView(params: ShowViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+}

package/dist/generated/dynamic-table/services/views.service.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewsService = void 0;
+class ViewsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listViews(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/views`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/views`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteView(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getView(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateView(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async setDefaultView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/default`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async duplicateView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/duplicate`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async hideView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/hide-all`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async showView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/show-all`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.ViewsService = ViewsService;

package/dist/generated/dynamic-table/services/workspace-invite-link-settings.service.d.ts

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, DeleteSettingsParams, GetSettingsParams, UpsertSettingsParams, WorkspaceInviteLinkSettingsResponseDto } from '../types';
+export declare class WorkspaceInviteLinkSettingsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteSettings(params: DeleteSettingsParams): Promise<ApiResponseDto<null>>;
+    getSettings(params: GetSettingsParams): Promise<ApiResponseDto<WorkspaceInviteLinkSettingsResponseDto>>;
+    upsertSettings(params: UpsertSettingsParams): Promise<ApiResponseDto<WorkspaceInviteLinkSettingsResponseDto>>;
+}

package/dist/generated/dynamic-table/services/workspace-invite-link-settings.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceInviteLinkSettingsService = void 0;
+class WorkspaceInviteLinkSettingsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteSettings(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/invite-link-settings`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getSettings(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/invite-link-settings`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async upsertSettings(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/invite-link-settings`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.WorkspaceInviteLinkSettingsService = WorkspaceInviteLinkSettingsService;

package/dist/generated/dynamic-table/services/workspace-invite-links.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateInviteLinkParams, GetInviteLinkParams, GetOrCreateInviteLinkParams, RequestJoinParams, WorkspaceInviteLinkResponseDto, WorkspaceJoinRequestResponseDto } from '../types';
+export declare class WorkspaceInviteLinksService {
+    private readonly client;
+    constructor(client: HttpClient);
+    requestJoin(params: RequestJoinParams): Promise<ApiResponseDto<WorkspaceJoinRequestResponseDto>>;
+    getInviteLink(params: GetInviteLinkParams): Promise<ApiResponseDto<WorkspaceInviteLinkResponseDto>>;
+    createInviteLink(params: CreateInviteLinkParams): Promise<ApiResponseDto<WorkspaceInviteLinkResponseDto>>;
+    getOrCreateInviteLink(params: GetOrCreateInviteLinkParams): Promise<ApiResponseDto<WorkspaceInviteLinkResponseDto>>;
+}