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

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

@@ -0,0 +1,17 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, BulkColumnsParams, ColumnResponseDto, CreateColumnParams, DeleteColumnParams, GetColumnParams, GetColumnsHashParams, ReorderColumnsParams, SetPrimaryColumnParams, UpdateColumnParams } from '../types';
+export declare class ColumnsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteColumn(params: DeleteColumnParams): Promise<ApiResponseDto<void>>;
+    getColumn(params: GetColumnParams): Promise<ApiResponseDto<ColumnResponseDto>>;
+    updateColumn(params: UpdateColumnParams): Promise<ApiResponseDto<ColumnResponseDto>>;
+    setPrimaryColumn(params: SetPrimaryColumnParams): Promise<ApiResponseDto<ColumnResponseDto>>;
+    createColumn(params: CreateColumnParams): Promise<ApiResponseDto<ColumnResponseDto>>;
+    bulkColumns(params: BulkColumnsParams): Promise<ApiResponseDto<null>>;
+    getColumnsHash(params: GetColumnsHashParams): Promise<ApiResponseDto<{
+        hash: string;
+        total: number;
+    }>>;
+    reorderColumns(params: ReorderColumnsParams): Promise<ApiResponseDto<null>>;
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnsService = void 0;
+class ColumnsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteColumn(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getColumn(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateColumn(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async setPrimaryColumn(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/columns/${encodeURIComponent(String(params.columnId))}/primary`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createColumn(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/columns`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async bulkColumns(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/columns/bulk`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async getColumnsHash(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/columns/hash`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async reorderColumns(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/columns/reorder`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.ColumnsService = ColumnsService;

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

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, PinParams, RecentParams, SearchParams } from '../types';
+export declare class CommandPaletteService {
+    private readonly client;
+    constructor(client: HttpClient);
+    pin(params: PinParams): Promise<ApiResponseDto<Record<string, unknown>[]>>;
+    recent(params?: RecentParams): Promise<ApiResponseDto<Record<string, unknown>[]>>;
+    search(params?: SearchParams): Promise<ApiResponseDto<Record<string, unknown>[]>>;
+}

package/dist/generated/dynamic-table/services/command-palette.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandPaletteService = void 0;
+class CommandPaletteService {
+    constructor(client) {
+        this.client = client;
+    }
+    async pin(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/command-palette/pin`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async recent(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/command-palette/recent`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async search(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/command-palette/search`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.CommandPaletteService = CommandPaletteService;

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

@@ -0,0 +1,13 @@
+import { HttpClient } from '../../../core/http-client';
+import type { AddReactionParams, ApiResponseDto, CommentCountItemResponseDto, CommentReactionResponseDto, CommentResponseDto, CountCommentsParams, CreateCommentParams, DeleteCommentParams, ListCommentsParams, RemoveReactionParams, UpdateCommentParams } from '../types';
+export declare class CommentsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteComment(params: DeleteCommentParams): Promise<ApiResponseDto<null>>;
+    updateComment(params: UpdateCommentParams): Promise<ApiResponseDto<CommentResponseDto>>;
+    listComments(params?: ListCommentsParams): Promise<ApiResponseDto<CommentResponseDto[]>>;
+    createComment(params: CreateCommentParams): Promise<ApiResponseDto<CommentResponseDto>>;
+    addReaction(params: AddReactionParams): Promise<ApiResponseDto<CommentReactionResponseDto>>;
+    removeReaction(params: RemoveReactionParams): Promise<ApiResponseDto<null>>;
+    countComments(params?: CountCommentsParams): Promise<ApiResponseDto<CommentCountItemResponseDto[]>>;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentsService = void 0;
+class CommentsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteComment(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/comment/${encodeURIComponent(String(params.commentId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateComment(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/comment/${encodeURIComponent(String(params.commentId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listComments(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/comments`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createComment(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/comments`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async addReaction(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/comments/${encodeURIComponent(String(params.commentId))}/reactions`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async removeReaction(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/comments/${encodeURIComponent(String(params.commentId))}/reactions/${encodeURIComponent(String(params.reaction))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async countComments(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/comments/count`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.CommentsService = CommentsService;

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

@@ -0,0 +1,15 @@
+import { HttpClient } from '../../../core/http-client';
+import type { AbortImportJobParams, ApiResponseDto, GetImportJobParams, ImportFromUrlParams, ImportJobResponseDto, ImportPreviewResponseDto, ImportStartResponseDto, ImportUploadResponseDto, PreviewImportFileParams, StartImportParams, UploadImportFileParams } from '../types';
+export declare class DataImportsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    startImport(params: StartImportParams): Promise<ApiResponseDto<ImportStartResponseDto>>;
+    getImportJob(params: GetImportJobParams): Promise<ApiResponseDto<ImportJobResponseDto>>;
+    abortImportJob(params: AbortImportJobParams): Promise<ApiResponseDto<{
+        id: string;
+        status: string;
+    }>>;
+    previewImportFile(params: PreviewImportFileParams): Promise<ApiResponseDto<ImportPreviewResponseDto>>;
+    uploadImportFile(params: UploadImportFileParams): Promise<ApiResponseDto<ImportUploadResponseDto>>;
+    importFromUrl(params: ImportFromUrlParams): Promise<ApiResponseDto<ImportUploadResponseDto>>;
+}

package/dist/generated/dynamic-table/services/data-imports.service.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataImportsService = void 0;
+class DataImportsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async startImport(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/data/imports`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async getImportJob(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/data/imports/${encodeURIComponent(String(params.jobId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async abortImportJob(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/data/imports/${encodeURIComponent(String(params.jobId))}/abort`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async previewImportFile(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/data/imports/preview`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async uploadImportFile(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/data/imports/upload`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async importFromUrl(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/data/imports/url`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.DataImportsService = DataImportsService;

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

@@ -0,0 +1,33 @@
+import { HttpClient } from '../../../core/http-client';
+import type { AggregateRecordsParams, ApiResponseDto, BulkDataListParams, BulkGroupByParams, CountRecordsParams, CreateRecordsParams, DeleteRecordsParams, GetRecordParams, GroupByParams, JsonValue, LinkRecordsBulkParams, LinkRecordsParams, ListLinkedRecordsParams, ListRecordsParams, MoveRecordParams, PagedResponse, TableRecord, UnlinkRecordsBulkParams, UnlinkRecordsParams, UpdateRecordFieldParams, UpdateRecordsParams } from '../types';
+export declare class DataTableService {
+    private readonly client;
+    constructor(client: HttpClient);
+    aggregateRecords(params: AggregateRecordsParams): Promise<ApiResponseDto<Record<string, number>>>;
+    bulkDataList(params: BulkDataListParams): Promise<ApiResponseDto<PagedResponse<TableRecord>>>;
+    bulkGroupBy(params: BulkGroupByParams): Promise<ApiResponseDto<{
+        groupValue: JsonValue;
+        total: number | string;
+    }[]>>;
+    groupBy(params: GroupByParams): Promise<ApiResponseDto<{
+        groupValue: JsonValue;
+        total: number | string;
+    }[]>>;
+    unlinkRecordsBulk(params: UnlinkRecordsBulkParams): Promise<ApiResponseDto<null>>;
+    linkRecordsBulk(params: LinkRecordsBulkParams): Promise<ApiResponseDto<null>>;
+    unlinkRecords(params: UnlinkRecordsParams): Promise<ApiResponseDto<null>>;
+    listLinkedRecords(params: ListLinkedRecordsParams): Promise<ApiResponseDto<{
+        refRowIds: string[];
+    }>>;
+    linkRecords(params: LinkRecordsParams): Promise<ApiResponseDto<null>>;
+    deleteRecords(params: DeleteRecordsParams): Promise<ApiResponseDto<null>>;
+    listRecords(params: ListRecordsParams): Promise<ApiResponseDto<PagedResponse<TableRecord>>>;
+    updateRecords(params: UpdateRecordsParams): Promise<ApiResponseDto<TableRecord | TableRecord[]>>;
+    createRecords(params: CreateRecordsParams): Promise<ApiResponseDto<TableRecord | TableRecord[]>>;
+    getRecord(params: GetRecordParams): Promise<ApiResponseDto<TableRecord>>;
+    updateRecordField(params: UpdateRecordFieldParams): Promise<ApiResponseDto<TableRecord>>;
+    moveRecord(params: MoveRecordParams): Promise<ApiResponseDto<TableRecord>>;
+    countRecords(params: CountRecordsParams): Promise<ApiResponseDto<{
+        count: number;
+    }>>;
+}

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTableService = void 0;
+class DataTableService {
+    constructor(client) {
+        this.client = client;
+    }
+    async aggregateRecords(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/aggregate`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async bulkDataList(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/bulk/datalist`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async bulkGroupBy(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/bulk/group`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async groupBy(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/groupby/${encodeURIComponent(String(params.fieldId))}`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async unlinkRecordsBulk(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/links/${encodeURIComponent(String(params.fieldId))}/records`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async linkRecordsBulk(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/links/${encodeURIComponent(String(params.fieldId))}/records`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async unlinkRecords(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/links/${encodeURIComponent(String(params.fieldId))}/records/${encodeURIComponent(String(params.recordId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listLinkedRecords(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/links/${encodeURIComponent(String(params.fieldId))}/records/${encodeURIComponent(String(params.recordId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async linkRecords(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/links/${encodeURIComponent(String(params.fieldId))}/records/${encodeURIComponent(String(params.recordId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteRecords(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listRecords(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateRecords(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async createRecords(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async getRecord(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records/${encodeURIComponent(String(params.recordId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateRecordField(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records/${encodeURIComponent(String(params.recordId))}/fields/${encodeURIComponent(String(params.fieldId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async moveRecord(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records/${encodeURIComponent(String(params.recordId))}/move`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async countRecords(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/records/count`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.DataTableService = DataTableService;

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

@@ -0,0 +1,7 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, DynamicTableTokenExchangeResponseDto, ExchangeTokenParams } from '../types';
+export declare class DynamicTableAuthService {
+    private readonly client;
+    constructor(client: HttpClient);
+    exchangeToken(params?: ExchangeTokenParams): Promise<ApiResponseDto<DynamicTableTokenExchangeResponseDto>>;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicTableAuthService = void 0;
+class DynamicTableAuthService {
+    constructor(client) {
+        this.client = client;
+    }
+    async exchangeToken(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/auth/exchange`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.DynamicTableAuthService = DynamicTableAuthService;

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

@@ -0,0 +1,12 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateFilterParams, DeleteFilterParams, FilterResponseDto, GetFilterParams, ListChildrenParams, ListFiltersParams, UpdateFilterParams } from '../types';
+export declare class FiltersService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteFilter(params: DeleteFilterParams): Promise<ApiResponseDto<void>>;
+    getFilter(params: GetFilterParams): Promise<ApiResponseDto<FilterResponseDto>>;
+    updateFilter(params: UpdateFilterParams): Promise<ApiResponseDto<FilterResponseDto>>;
+    listChildren(params: ListChildrenParams): Promise<ApiResponseDto<FilterResponseDto[]>>;
+    listFilters(params: ListFiltersParams): Promise<ApiResponseDto<FilterResponseDto[]>>;
+    createFilter(params: CreateFilterParams): Promise<ApiResponseDto<FilterResponseDto>>;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FiltersService = void 0;
+class FiltersService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteFilter(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getFilter(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateFilter(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listChildren(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/filters/${encodeURIComponent(String(params.filterParentId))}/children`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async listFilters(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/filters`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createFilter(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/views/${encodeURIComponent(String(params.viewId))}/filters`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.FiltersService = FiltersService;

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

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateFormViewParams, FormViewDetailResponseDto, FormViewResponseDto, GetFormViewParams, UpdateFormViewParams, ViewResponseDto } from '../types';
+export declare class FormsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getFormView(params: GetFormViewParams): Promise<ApiResponseDto<FormViewDetailResponseDto>>;
+    updateFormView(params: UpdateFormViewParams): Promise<ApiResponseDto<FormViewResponseDto>>;
+    createFormView(params: CreateFormViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormsService = void 0;
+class FormsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getFormView(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/forms/${encodeURIComponent(String(params.formViewId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateFormView(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/forms/${encodeURIComponent(String(params.formViewId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async createFormView(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/tables/${encodeURIComponent(String(params.tableId))}/forms`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.FormsService = FormsService;