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

package/dist/core/auth.d.ts

@@ -0,0 +1,19 @@
+import { DynamicTableTokenProvider } from './types';
+export interface AuthState {
+    bearerToken: string | null;
+    dtApiToken: string | null;
+}
+export declare class DynamicTableAuth {
+    private state;
+    private tokenProvider;
+    constructor(initial?: Partial<AuthState>, tokenProvider?: DynamicTableTokenProvider);
+    getState(): Readonly<AuthState>;
+    setTokenProvider(provider: DynamicTableTokenProvider | null): void;
+    resolveState(): Promise<Readonly<AuthState>>;
+    setBearerToken(token: string | null): void;
+    setDtApiToken(token: string | null): void;
+    setAuth(input: {
+        bearerToken?: string | null;
+        dtApiToken?: string | null;
+    }): void;
+}

package/dist/core/auth.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicTableAuth = void 0;
+class DynamicTableAuth {
+    constructor(initial, tokenProvider) {
+        this.tokenProvider = null;
+        this.state = {
+            bearerToken: initial?.bearerToken ?? null,
+            dtApiToken: initial?.dtApiToken ?? null,
+        };
+        this.tokenProvider = tokenProvider ?? null;
+    }
+    getState() {
+        return this.state;
+    }
+    setTokenProvider(provider) {
+        this.tokenProvider = provider;
+    }
+    async resolveState() {
+        if (!this.tokenProvider) {
+            return this.state;
+        }
+        const [providerBearer, providerDtApiToken] = await Promise.all([
+            this.tokenProvider.getBearerToken?.(),
+            this.tokenProvider.getDtApiToken?.(),
+        ]);
+        return {
+            bearerToken: providerBearer === undefined ? this.state.bearerToken : (providerBearer ?? null),
+            dtApiToken: providerDtApiToken === undefined ? this.state.dtApiToken : (providerDtApiToken ?? null),
+        };
+    }
+    setBearerToken(token) {
+        this.state.bearerToken = token;
+    }
+    setDtApiToken(token) {
+        this.state.dtApiToken = token;
+    }
+    setAuth(input) {
+        if (Object.prototype.hasOwnProperty.call(input, 'bearerToken')) {
+            this.state.bearerToken = input.bearerToken ?? null;
+        }
+        if (Object.prototype.hasOwnProperty.call(input, 'dtApiToken')) {
+            this.state.dtApiToken = input.dtApiToken ?? null;
+        }
+    }
+}
+exports.DynamicTableAuth = DynamicTableAuth;

package/dist/core/http-client.d.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig } from 'axios';
+import { DynamicTableAuth } from './auth';
+import { DynamicTableSdkConfig } from './types';
+export declare class HttpClient {
+    private readonly auth;
+    private readonly instance;
+    constructor(config: DynamicTableSdkConfig, auth: DynamicTableAuth);
+    request<T>(config: AxiosRequestConfig): Promise<T>;
+}

package/dist/core/http-client.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class HttpClient {
+    constructor(config, auth) {
+        this.auth = auth;
+        this.instance = axios_1.default.create({
+            baseURL: config.baseURL,
+            timeout: config.timeout ?? 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(config.defaultHeaders ?? {}),
+            },
+        });
+        this.instance.interceptors.request.use(async (requestConfig) => {
+            const state = await this.auth.resolveState();
+            if (state.bearerToken) {
+                requestConfig.headers.Authorization = `Bearer ${state.bearerToken}`;
+            }
+            else if (requestConfig.headers.Authorization) {
+                delete requestConfig.headers.Authorization;
+            }
+            if (state.dtApiToken) {
+                requestConfig.headers['x-dt-api-token'] = state.dtApiToken;
+            }
+            else if (requestConfig.headers['x-dt-api-token']) {
+                delete requestConfig.headers['x-dt-api-token'];
+            }
+            return requestConfig;
+        });
+    }
+    async request(config) {
+        const response = await this.instance.request(config);
+        return response.data;
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/core/types.d.ts

@@ -0,0 +1,19 @@
+export type Nullable<T> = T | null;
+export interface ApiResponseDto<T> {
+    code: number;
+    message: string;
+    result: T;
+}
+export type MaybePromise<T> = T | Promise<T>;
+export interface DynamicTableTokenProvider {
+    getBearerToken?: () => MaybePromise<string | null | undefined>;
+    getDtApiToken?: () => MaybePromise<string | null | undefined>;
+}
+export interface DynamicTableSdkConfig {
+    baseURL: string;
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    bearerToken?: string | null;
+    dtApiToken?: string | null;
+    tokenProvider?: DynamicTableTokenProvider;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src/generated/dynamic-table/index.ts → dist/generated/dynamic-table/index.d.ts}

@@ -1,3 +1,2 @@
-/* eslint-disable */
 export * from './types';
 export * from './services';

package/dist/generated/dynamic-table/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable */
+__exportStar(require("./types"), exports);
+__exportStar(require("./services"), exports);

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

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, OpenApiJsonParams, RedocParams, SwaggerParams } from '../types';
+export declare class ApiDocsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    openApiJson(params?: OpenApiJsonParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    redoc(params?: RedocParams): Promise<ApiResponseDto<string>>;
+    swagger(params?: SwaggerParams): Promise<ApiResponseDto<string>>;
+}

package/dist/generated/dynamic-table/services/api-docs.service.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDocsService = void 0;
+class ApiDocsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async openApiJson(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/api-docs/openapi.json`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async redoc(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/api-docs/redoc`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async swagger(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/api-docs/swagger`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.ApiDocsService = ApiDocsService;

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

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateApiTokenParams, DeleteApiTokenParams, ListApiTokensParams, UpdateApiTokenParams } from '../types';
+export declare class ApiTokensService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listApiTokens(params?: ListApiTokensParams): Promise<ApiResponseDto<Record<string, unknown>[]>>;
+    createApiToken(params: CreateApiTokenParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    deleteApiToken(params: DeleteApiTokenParams): Promise<ApiResponseDto<null>>;
+    updateApiToken(params: UpdateApiTokenParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+}

package/dist/generated/dynamic-table/services/api-tokens.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTokensService = void 0;
+class ApiTokensService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listApiTokens(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/api-tokens`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createApiToken(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/api-tokens`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async deleteApiToken(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/api-tokens/${encodeURIComponent(String(params.tokenId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateApiToken(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/api-tokens/${encodeURIComponent(String(params.tokenId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.ApiTokensService = ApiTokensService;

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

@@ -0,0 +1,8 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreateSecureTokenParams, GetSecureAttachmentParams } from '../types';
+export declare class AttachmentsSecureService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getSecureAttachment(params: GetSecureAttachmentParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    createSecureToken(params: CreateSecureTokenParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+}

package/dist/generated/dynamic-table/services/attachments-secure.service.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentsSecureService = void 0;
+class AttachmentsSecureService {
+    constructor(client) {
+        this.client = client;
+    }
+    async getSecureAttachment(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/storage/secure/${encodeURIComponent(String(params.attachmentId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createSecureToken(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/storage/secure/${encodeURIComponent(String(params.attachmentId))}/token`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.AttachmentsSecureService = AttachmentsSecureService;

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

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CreatePresignedUrlParams, DeleteAttachmentParams, GetAttachmentParams, UploadParams } from '../types';
+export declare class AttachmentsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteAttachment(params: DeleteAttachmentParams): Promise<ApiResponseDto<null>>;
+    getAttachment(params: GetAttachmentParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    createPresignedUrl(params: CreatePresignedUrlParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    upload(params: UploadParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentsService = void 0;
+class AttachmentsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteAttachment(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/storage/${encodeURIComponent(String(params.attachmentId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getAttachment(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/storage/${encodeURIComponent(String(params.attachmentId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createPresignedUrl(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/storage/presigned-url`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async upload(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/storage/upload`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.AttachmentsService = AttachmentsService;

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

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../../core/http-client';
+import type { AddBaseMemberParams, ApiResponseDto, BaseMemberListResponseDto, BaseMemberResponseDto, ListBaseMembersParams, RemoveBaseMemberParams, UpdateBaseMemberParams } from '../types';
+export declare class BaseMembersService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listBaseMembers(params: ListBaseMembersParams): Promise<ApiResponseDto<BaseMemberListResponseDto>>;
+    addBaseMember(params: AddBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>>;
+    removeBaseMember(params: RemoveBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>>;
+    updateBaseMember(params: UpdateBaseMemberParams): Promise<ApiResponseDto<BaseMemberResponseDto>>;
+}

package/dist/generated/dynamic-table/services/base-members.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMembersService = void 0;
+class BaseMembersService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listBaseMembers(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async addBaseMember(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async removeBaseMember(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members/${encodeURIComponent(String(params.baseMemberId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateBaseMember(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}/members/${encodeURIComponent(String(params.baseMemberId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.BaseMembersService = BaseMembersService;

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

@@ -0,0 +1,11 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, BaseResponseDto, CreateBaseParams, DeleteBaseParams, GetBaseParams, ListBasesParams, PagedResponse, UpdateBaseParams } from '../types';
+export declare class BasesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    deleteBase(params: DeleteBaseParams): Promise<ApiResponseDto<BaseResponseDto>>;
+    getBase(params: GetBaseParams): Promise<ApiResponseDto<BaseResponseDto>>;
+    updateBase(params: UpdateBaseParams): Promise<ApiResponseDto<BaseResponseDto>>;
+    listBases(params: ListBasesParams): Promise<ApiResponseDto<PagedResponse<BaseResponseDto>>>;
+    createBase(params: CreateBaseParams): Promise<ApiResponseDto<BaseResponseDto>>;
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasesService = void 0;
+class BasesService {
+    constructor(client) {
+        this.client = client;
+    }
+    async deleteBase(params) {
+        return this.client.request({
+            method: 'DELETE',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async getBase(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async updateBase(params) {
+        return this.client.request({
+            method: 'PATCH',
+            url: `/v1/dynamic-table/db/meta/bases/${encodeURIComponent(String(params.baseId))}`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+    async listBases(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/bases`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async createBase(params) {
+        return this.client.request({
+            method: 'POST',
+            url: `/v1/dynamic-table/db/meta/workspaces/${encodeURIComponent(String(params.workspaceId))}/bases`,
+            params: undefined,
+            data: params?.body,
+            headers: undefined,
+        });
+    }
+}
+exports.BasesService = BasesService;

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

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, InvalidateParams, StatsParams, WarmupParams } from '../types';
+export declare class CachesService {
+    private readonly client;
+    constructor(client: HttpClient);
+    invalidate(params: InvalidateParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    stats(params?: StatsParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+    warmup(params: WarmupParams): Promise<ApiResponseDto<Record<string, unknown>>>;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CountByDateParams, CountRangeParams, ListCalendarRecordsParams, PagedResponse, TableRecord } from '../types';
+export declare class CalendarDataService {
+    private readonly client;
+    constructor(client: HttpClient);
+    listCalendarRecords(params: ListCalendarRecordsParams): Promise<ApiResponseDto<PagedResponse<TableRecord>>>;
+    countByDate(params: CountByDateParams): Promise<ApiResponseDto<{
+        count: number;
+        dates: string[];
+    }>>;
+    countRange(params: CountRangeParams): Promise<ApiResponseDto<{
+        count: number;
+    }>>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarDataService = void 0;
+class CalendarDataService {
+    constructor(client) {
+        this.client = client;
+    }
+    async listCalendarRecords(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async countByDate(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records/count-by-date`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+    async countRange(params) {
+        return this.client.request({
+            method: 'GET',
+            url: `/v1/dynamic-table/tables/${encodeURIComponent(String(params.tableId))}/calendars/${encodeURIComponent(String(params.viewId))}/records/count-range`,
+            params: params?.query,
+            data: undefined,
+            headers: undefined,
+        });
+    }
+}
+exports.CalendarDataService = CalendarDataService;

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

@@ -0,0 +1,9 @@
+import { HttpClient } from '../../../core/http-client';
+import type { ApiResponseDto, CalendarViewDetailResponseDto, CalendarViewResponseDto, CreateCalendarViewParams, GetCalendarViewParams, UpdateCalendarViewParams, ViewResponseDto } from '../types';
+export declare class CalendarsService {
+    private readonly client;
+    constructor(client: HttpClient);
+    getCalendarView(params: GetCalendarViewParams): Promise<ApiResponseDto<CalendarViewDetailResponseDto>>;
+    updateCalendarView(params: UpdateCalendarViewParams): Promise<ApiResponseDto<CalendarViewResponseDto>>;
+    createCalendarView(params: CreateCalendarViewParams): Promise<ApiResponseDto<ViewResponseDto>>;
+}

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

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