skapi-js 0.2.5 → 1.0.0-alpha.10

package/js/Types.d.ts

@@ -123,10 +123,28 @@ export type UserProfile = {
     phone_number_verified?: boolean;
     signup_ticket?: string;
 } & UserAttributes;
-export interface User extends UserProfile {
+export type PublicUser = {
+    name?: string;
+    email?: string;
+    phone_number?: string;
+    address?: string | {
+        formatted: string;
+        locality: string;
+        region: string;
+        postal_code: string;
+        country: string;
+    };
+    gender?: string;
+    birthdate?: string;
+    misc?: string;
     subscribers: number;
     timestamp: number;
-}
+    service: string;
+    owner: string;
+    access_group?: number;
+    user_id: string;
+    locale: string;
+};
 export type QueryParams = {
     searchFor: string;
     value: string | number | boolean;

package/js/main/skapi.d.ts

@@ -1,22 +1,23 @@
-import { User, Connection } from '../Types';
+import { DatabaseResponse, Connection, ProgressCallback, GetRecordQuery, FetchOptions, RecordData, Condition, QueryParams, UserAttributes, UserProfile, Newsletters, FormSubmitCallback, Form, PostRecordConfig, PublicUser, SubscriptionGroup } from '../Types';
 export default class Skapi {
     version: string;
+    service: string;
+    owner: string;
+    session: Record<string, any> | null;
+    connection: Connection | null;
+    private host;
+    private hostDomain;
+    private target_cdn;
     private __disabledAccount;
     private __cached_requests;
     private __startKeyHistory;
     private __request_signup_confirmation;
-    service: string;
-    owner: string;
     private __class_properties_has_been_cached;
-    session: Record<string, any> | null;
-    __user: User | null;
-    get user(): User | null;
-    set user(value: User | null);
-    connection: Connection | null;
-    host: string;
-    hostDomain: string;
-    admin_endpoint: Promise<Record<string, any>>;
-    record_endpoint: Promise<Record<string, any>>;
+    private __user;
+    get user(): UserProfile | null;
+    set user(value: UserProfile | null);
+    private admin_endpoint;
+    private record_endpoint;
     validate: {
         userId(val: string): boolean;
         url(val: string | string[]): boolean;
@@ -24,56 +25,193 @@ export default class Skapi {
         birthdate(val: string): boolean;
         email(val: string): boolean;
     };
-    __connection: Promise<Connection | null>;
-    constructor(service_id: string, owner: string, options?: {
+    private __connection;
+    constructor(service: string, owner: string, options?: {
         autoLogin: boolean;
     });
     updateConnection(): Promise<Connection>;
-    getConnection: any;
-    getProfile: any;
-    checkAdmin: any;
-    getFile: any;
-    request: any;
-    secureRequest: any;
-    getFormResponse: any;
-    getRecords: any;
-    getTables: any;
-    getIndexes: any;
-    getTags: any;
-    deleteRecords: any;
-    resendSignupConfirmation: any;
-    recoverAccount: any;
-    getUsers: any;
-    disableAccount: any;
-    lastVerifiedEmail: any;
-    getSubscribedTo: any;
-    getSubscribers: any;
-    getSubscriptions: any;
-    unsubscribeNewsletter: any;
-    getNewsletters: any;
-    getNewsletterSubscription: any;
-    requestUsernameChange: any;
-    grantPrivateRecordAccess: any;
-    removePrivateRecordAccess: any;
-    listPrivateRecordAccess: any;
-    requestPrivateRecordAccessKey: any;
-    listHostDirectory: any;
-    deleteFiles: any;
-    uploadFiles(...args: any[]): any;
-    mock(...args: any[]): any;
-    login(...args: any[]): any;
-    logout(...args: any[]): any;
-    signup(...args: any[]): any;
-    resetPassword(...args: any[]): any;
-    verifyEmail(...args: any[]): any;
-    verifyPhoneNumber(...args: any[]): any;
-    forgotPassword(...args: any[]): any;
-    changePassword(...args: any[]): any;
-    updateProfile(...args: any[]): any;
-    postRecord(...args: any[]): any;
-    subscribe(...args: any[]): any;
-    unsubscribe(...args: any[]): any;
-    blockSubscriber(...args: any[]): any;
-    unblockSubscriber(...args: any[]): any;
-    subscribeNewsletter(...args: any[]): any;
+    private checkAdmin;
+    private request;
+    private getSubscribedTo;
+    private getSubscribers;
+    getConnection(): Promise<Connection>;
+    getProfile(options?: {
+        refreshToken: boolean;
+    }): Promise<UserProfile | null>;
+    getFile(url: string, config?: {
+        noCdn?: boolean;
+        dataType?: 'base64' | 'download' | 'endpoint' | 'blob';
+        expiration?: number;
+        progress?: ProgressCallback;
+    }): Promise<Blob | string>;
+    secureRequest<Params = {
+        url: string;
+        data?: any;
+        sync?: boolean;
+    }>(params: Params | Params[]): Promise<any>;
+    getFormResponse(): Promise<any>;
+    getRecords(query: GetRecordQuery, fetchOptions?: FetchOptions): Promise<DatabaseResponse<RecordData>>;
+    getTables(query: {
+        table: string;
+        condition?: Condition;
+    }, fetchOptions?: FetchOptions): Promise<DatabaseResponse<{
+        number_of_records: number;
+        table: string;
+        size: number;
+    }>>;
+    getIndexes(query: {
+        table: string;
+        index?: string;
+        order?: {
+            by: 'average_number' | 'total_number' | 'number_count' | 'average_bool' | 'total_bool' | 'bool_count' | 'string_count' | 'index_name';
+            value?: number | boolean | string;
+            condition?: Condition;
+        };
+    }, fetchOptions?: FetchOptions): Promise<DatabaseResponse<{
+        table: string;
+        index: string;
+        number_of_records: number;
+        string_count?: number;
+        number_count?: number;
+        boolean_count?: number;
+        total_number?: number;
+        total_bool?: number;
+        average_number?: number;
+        average_bool?: number;
+    }>>;
+    getTags(query: {
+        table: string;
+        tag?: string;
+        condition?: Condition;
+    }, fetchOptions?: FetchOptions): Promise<DatabaseResponse<{
+        table: string;
+        tag: string;
+        number_of_records: string;
+    }>>;
+    deleteRecords(params: {
+        record_id?: string | string[];
+        table?: {
+            name: string;
+            access_group?: number | 'private' | 'public' | 'authorized';
+            subscription_group?: number;
+        };
+    }): Promise<string>;
+    resendSignupConfirmation(redirect: string): Promise<'SUCCESS: Signup confirmation E-Mail has been sent.'>;
+    recoverAccount(redirect?: boolean | string): Promise<"SUCCESS: Recovery e-mail has been sent.">;
+    getUsers(params?: QueryParams | null, fetchOptions?: FetchOptions): Promise<DatabaseResponse<PublicUser>>;
+    disableAccount(): Promise<'SUCCESS: account has been disabled.'>;
+    lastVerifiedEmail(params?: {
+        revert: boolean;
+    }): Promise<string | UserProfile>;
+    getSubscriptions(params: {
+        subscriber?: string;
+        subscription?: string;
+        group?: number;
+        blocked?: boolean;
+    }, fetchOptions?: FetchOptions, _mapper?: (data: Record<string, any>) => any): Promise<DatabaseResponse<{
+        subscriber: string;
+        subscription: string;
+        group: number;
+        timestamp: number;
+        blocked: boolean;
+    }>>;
+    unsubscribeNewsletter(params: {
+        group: number | 'public' | 'authorized' | null;
+    }): Promise<string>;
+    getNewsletters(params?: {
+        searchFor: 'message_id' | 'timestamp' | 'read' | 'complaint' | 'subject';
+        value: string | number;
+        range: string | number;
+        condition?: '>' | '>=' | '=' | '<' | '<=' | 'gt' | 'gte' | 'eq' | 'lt' | 'lte';
+        group: 'public' | 'authorized' | number;
+    }, fetchOptions?: FetchOptions): Promise<Newsletters>;
+    getNewsletterSubscription(params: {
+        group?: number;
+    }): Promise<{
+        active: boolean;
+        timestamp: number;
+        group: number;
+        subscribed_email: string;
+    }[]>;
+    requestUsernameChange(params: {
+        redirect?: string;
+        username: string;
+    }): Promise<'SUCCESS: confirmation e-mail has been sent.'>;
+    grantPrivateRecordAccess(params: {
+        record_id: string;
+        user_id: string | string[];
+    }): Promise<string>;
+    removePrivateRecordAccess(params: {
+        record_id: string;
+        user_id: string | string[];
+    }): Promise<string>;
+    listPrivateRecordAccess(params: {
+        record_id: string;
+        user_id: string | string[];
+    }): Promise<string>;
+    requestPrivateRecordAccessKey(record_id: string): Promise<string>;
+    deleteFiles(params: {
+        endpoints: string | string[];
+    }): Promise<RecordData[]>;
+    uploadFiles(fileList: Form<FileList | File[]>, params: {
+        record_id: string;
+    } & FormSubmitCallback): Promise<{
+        completed: File[];
+        failed: File[];
+    }>;
+    mock(data: Form<any | {
+        raise: 'ERR_INVALID_REQUEST' | 'ERR_INVALID_PARAMETER' | 'SOMETHING_WENT_WRONG' | 'ERR_EXISTS' | 'ERR_NOT_EXISTS';
+    }>, options?: {
+        auth?: boolean;
+        method?: string;
+        meta?: Record<string, any>;
+        bypassAwaitConnection?: boolean;
+        responseType?: string;
+        contentType?: string;
+    } & FormSubmitCallback): Promise<{
+        mockResponse: Record<string, any>;
+    }>;
+    login(form: Form<{
+        username: string;
+        email: string;
+        password: string;
+    }>): Promise<UserProfile>;
+    logout(): Promise<'SUCCESS: The user has been logged out.'>;
+    signup(form: Form<UserAttributes & {
+        email: String;
+        password: String;
+    }>, option?: {
+        signup_confirmation?: boolean | string;
+        email_subscription?: boolean;
+        login?: boolean;
+    } & FormSubmitCallback): Promise<UserProfile | "SUCCESS: The account has been created. User's signup confirmation is required." | 'SUCCESS: The account has been created.'>;
+    resetPassword(form: Form<{
+        email: string;
+        code?: string | number;
+        new_password?: string;
+    }>): Promise<"SUCCESS: New password has been set.">;
+    verifyEmail(form?: Form<{
+        code: string;
+    }>): Promise<'SUCCESS: Verification code has been sent.' | 'SUCCESS: "email" is verified.'>;
+    verifyPhoneNumber(form?: Form<{
+        code: string;
+    }>): Promise<'SUCCESS: Verification code has been sent.' | 'SUCCESS: "phone_number" is verified.'>;
+    forgotPassword(form: Form<{
+        email: string;
+    }>): Promise<"SUCCESS: Verification code has been sent.">;
+    changePassword(params: {
+        new_password: string;
+        current_password: string;
+    }): Promise<'SUCCESS: Password has been changed.'>;
+    updateProfile(form: Form<UserAttributes>): Promise<UserProfile>;
+    postRecord(form: Form<Record<string, any>> | null | undefined, config: PostRecordConfig & FormSubmitCallback): Promise<RecordData>;
+    subscribe(option: SubscriptionGroup<number>): Promise<'SUCCESS: the user has subscribed.'>;
+    unsubscribe(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: the user has unsubscribed.'>;
+    blockSubscriber(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: blocked user id "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".'>;
+    unblockSubscriber(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: unblocked user id "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".'>;
+    subscribeNewsletter(form: Form<{
+        email?: string;
+        group: number | 'public' | 'authorized';
+        redirect?: string;
+    }>): Promise<string>;
 }

package/js/main/skapi.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import SkapiError from './error';
 import validator from '../utils/validator';
 import { getRecords, postRecord, deleteRecords, getTables, getIndexes, getTags, uploadFiles, getFile, grantPrivateRecordAccess, removePrivateRecordAccess, listPrivateRecordAccess, requestPrivateRecordAccessKey, deleteFiles } from '../methods/database';
-import { request, secureRequest, mock, getFormResponse, formHandler, getConnection, listHostDirectory } from '../methods/request';
+import { request, secureRequest, mock, getFormResponse, formHandler, getConnection } from '../methods/request';
 import { subscribe, unsubscribe, blockSubscriber, unblockSubscriber, getSubscribers, getSubscribedTo, getSubscriptions, subscribeNewsletter, getNewsletters, unsubscribeNewsletter, getNewsletterSubscription } from '../methods/subscription';
 import { checkAdmin, getProfile, logout, recoverAccount, resendSignupConfirmation, authentication, login, signup, disableAccount, resetPassword, verifyEmail, verifyPhoneNumber, forgotPassword, changePassword, updateProfile, getUsers, setUserPool, userPool, lastVerifiedEmail, requestUsernameChange } from '../methods/user';
 export default class Skapi {
@@ -21,18 +21,19 @@ export default class Skapi {
     }
     set user(value) {
     }
-    constructor(service_id, owner, options) {
-        this.version = '0.2.5';
+    constructor(service, owner, options) {
+        this.version = '1.0.0-alpha.10';
+        this.session = null;
+        this.connection = null;
+        this.host = 'skapi';
+        this.hostDomain = 'skapi.app';
+        this.target_cdn = 'd1wrj5ymxrt2ir';
         this.__disabledAccount = null;
         this.__cached_requests = {};
         this.__startKeyHistory = {};
         this.__request_signup_confirmation = null;
         this.__class_properties_has_been_cached = false;
-        this.session = null;
         this.__user = null;
-        this.connection = null;
-        this.host = 'skapi';
-        this.hostDomain = 'skapi.com';
         this.validate = {
             userId(val) {
                 try {
@@ -80,51 +81,24 @@ export default class Skapi {
                 }
             }
         };
-        this.getConnection = getConnection.bind(this);
-        this.getProfile = getProfile.bind(this);
         this.checkAdmin = checkAdmin.bind(this);
-        this.getFile = getFile.bind(this);
         this.request = request.bind(this);
-        this.secureRequest = secureRequest.bind(this);
-        this.getFormResponse = getFormResponse.bind(this);
-        this.getRecords = getRecords.bind(this);
-        this.getTables = getTables.bind(this);
-        this.getIndexes = getIndexes.bind(this);
-        this.getTags = getTags.bind(this);
-        this.deleteRecords = deleteRecords.bind(this);
-        this.resendSignupConfirmation = resendSignupConfirmation.bind(this);
-        this.recoverAccount = recoverAccount.bind(this);
-        this.getUsers = getUsers.bind(this);
-        this.disableAccount = disableAccount.bind(this);
-        this.lastVerifiedEmail = lastVerifiedEmail.bind(this);
         this.getSubscribedTo = getSubscribedTo.bind(this);
         this.getSubscribers = getSubscribers.bind(this);
-        this.getSubscriptions = getSubscriptions.bind(this);
-        this.unsubscribeNewsletter = unsubscribeNewsletter.bind(this);
-        this.getNewsletters = getNewsletters.bind(this);
-        this.getNewsletterSubscription = getNewsletterSubscription.bind(this);
-        this.requestUsernameChange = requestUsernameChange.bind(this);
-        this.grantPrivateRecordAccess = grantPrivateRecordAccess.bind(this);
-        this.removePrivateRecordAccess = removePrivateRecordAccess.bind(this);
-        this.listPrivateRecordAccess = listPrivateRecordAccess.bind(this);
-        this.requestPrivateRecordAccessKey = requestPrivateRecordAccessKey.bind(this);
-        this.listHostDirectory = listHostDirectory.bind(this);
-        this.deleteFiles = deleteFiles.bind(this);
-        if (typeof service_id !== 'string' || typeof owner !== 'string') {
-            throw new SkapiError('"service_id" and "owner" should be type <string>.', { code: 'INVALID_PARAMETER' });
+        if (typeof service !== 'string' || typeof owner !== 'string') {
+            throw new SkapiError('"service" and "owner" should be type <string>.', { code: 'INVALID_PARAMETER' });
         }
-        if (!service_id || !owner) {
-            throw new SkapiError('"service_id" and "owner" is required', { code: 'INVALID_PARAMETER' });
+        if (!service || !owner) {
+            throw new SkapiError('"service" and "owner" is required', { code: 'INVALID_PARAMETER' });
         }
         if (owner !== this.host) {
             validator.UserId(owner, '"owner"');
         }
-        this.service = service_id;
+        this.service = service;
         this.owner = owner;
         let autoLogin = typeof options?.autoLogin === 'boolean' ? options.autoLogin : true;
-        const target_cdn = 'd1h765tqb4s5ov';
-        const cdn_domain = `https://${target_cdn}.cloudfront.net`;
-        let sreg = service_id.substring(0, 4);
+        const cdn_domain = `https://${this.target_cdn}.cloudfront.net`;
+        let sreg = service.substring(0, 4);
         this.admin_endpoint = fetch(`${cdn_domain}/${sreg}/admin.json`)
             .then(response => response.blob())
             .then(blob => new Promise((resolve, reject) => {
@@ -147,7 +121,7 @@ export default class Skapi {
             if (!window.sessionStorage) {
                 throw new Error(`This browser does not support skapi.`);
             }
-            const restore = JSON.parse(window.sessionStorage.getItem(`${service_id}#${owner}`) || 'null');
+            const restore = JSON.parse(window.sessionStorage.getItem(`${service}#${owner}`) || 'null');
             if (restore?.connection) {
                 for (let k in restore) {
                     this[k] = restore[k];
@@ -172,7 +146,6 @@ export default class Skapi {
                 process.push(authentication.bind(this)().getSession({ refreshToken: !restore?.connection }).catch(err => {
                     this.__user = null;
                 }));
-                this.updateConnection();
             }
             let awaitProcess;
             if (process.length) {
@@ -194,7 +167,7 @@ export default class Skapi {
                         for (let k of to_be_cached) {
                             data[k] = this[k];
                         }
-                        window.sessionStorage.setItem(`${service_id}#${owner}`, JSON.stringify(data));
+                        window.sessionStorage.setItem(`${service}#${owner}`, JSON.stringify(data));
                         this.__class_properties_has_been_cached = true;
                     }
                 };
@@ -214,23 +187,104 @@ export default class Skapi {
         console.log(`Built with:\n${skapi}Version: ${this.version}\n\nDocumentation: https://docs.skapi.com`, `font-family: monospace; color:blue;`);
         return this.connection;
     }
-    uploadFiles(...args) { return uploadFiles.bind(this)(...args); }
-    mock(...args) { return mock.bind(this)(...args); }
-    login(...args) { return login.bind(this)(...args); }
-    logout(...args) { return logout.bind(this)(...args); }
-    signup(...args) { return signup.bind(this)(...args); }
-    resetPassword(...args) { return resetPassword.bind(this)(...args); }
-    verifyEmail(...args) { return verifyEmail.bind(this)(...args); }
-    verifyPhoneNumber(...args) { return verifyPhoneNumber.bind(this)(...args); }
-    forgotPassword(...args) { return forgotPassword.bind(this)(...args); }
-    changePassword(...args) { return changePassword.bind(this)(...args); }
-    updateProfile(...args) { return updateProfile.bind(this)(...args); }
-    postRecord(...args) { return postRecord.bind(this)(...args); }
-    subscribe(...args) { return subscribe.bind(this)(...args); }
-    unsubscribe(...args) { return unsubscribe.bind(this)(...args); }
-    blockSubscriber(...args) { return blockSubscriber.bind(this)(...args); }
-    unblockSubscriber(...args) { return unblockSubscriber.bind(this)(...args); }
-    subscribeNewsletter(...args) { return subscribeNewsletter.bind(this)(...args); }
+    getConnection() {
+        return getConnection.bind(this)();
+    }
+    getProfile(options) {
+        return getProfile.bind(this)(options);
+    }
+    getFile(url, config) {
+        return getFile.bind(this)(url, config);
+    }
+    secureRequest(params) {
+        return secureRequest.bind(this)(params);
+    }
+    getFormResponse() {
+        return getFormResponse.bind(this)();
+    }
+    getRecords(query, fetchOptions) {
+        return getRecords.bind(this)(query, fetchOptions);
+    }
+    getTables(query, fetchOptions) {
+        return getTables.bind(this)(query, fetchOptions);
+    }
+    getIndexes(query, fetchOptions) { return getIndexes.bind(this)(query, fetchOptions); }
+    getTags(query, fetchOptions) { return getTags.bind(this)(query, fetchOptions); }
+    deleteRecords(params) { return deleteRecords.bind(this)(params); }
+    resendSignupConfirmation(redirect) {
+        return resendSignupConfirmation.bind(this)(redirect);
+    }
+    recoverAccount(redirect = false) {
+        return recoverAccount.bind(this)(redirect);
+    }
+    getUsers(params, fetchOptions) {
+        return getUsers.bind(this)(params, fetchOptions);
+    }
+    disableAccount() {
+        return disableAccount.bind(this)();
+    }
+    lastVerifiedEmail(params) {
+        return lastVerifiedEmail.bind(this)(params);
+    }
+    getSubscriptions(params, fetchOptions, _mapper) {
+        return getSubscriptions.bind(this)(params, fetchOptions, _mapper);
+    }
+    unsubscribeNewsletter(params) {
+        return unsubscribeNewsletter.bind(this)(params);
+    }
+    getNewsletters(params, fetchOptions) {
+        return getNewsletters.bind(this)(params, fetchOptions);
+    }
+    getNewsletterSubscription(params) {
+        return getNewsletterSubscription.bind(this)(params);
+    }
+    requestUsernameChange(params) { return requestUsernameChange.bind(this)(params); }
+    grantPrivateRecordAccess(params) { return grantPrivateRecordAccess.bind(this)(params); }
+    removePrivateRecordAccess(params) {
+        return removePrivateRecordAccess.bind(this)(params);
+    }
+    listPrivateRecordAccess(params) { return listPrivateRecordAccess.bind(this)(params); }
+    requestPrivateRecordAccessKey(record_id) {
+        return requestPrivateRecordAccessKey.bind(this)(record_id);
+    }
+    deleteFiles(params) {
+        return deleteFiles.bind(this)(params);
+    }
+    uploadFiles(fileList, params) { return uploadFiles.bind(this)(fileList, params); }
+    mock(data, options) { return mock.bind(this)(data, options); }
+    login(form) { return login.bind(this)(form); }
+    logout() { return logout.bind(this)(); }
+    signup(form, option) {
+        return signup.bind(this)(form, option);
+    }
+    resetPassword(form) { return resetPassword.bind(this)(form); }
+    verifyEmail(form) {
+        return verifyEmail.bind(this)(form);
+    }
+    verifyPhoneNumber(form) {
+        return verifyPhoneNumber.bind(this)(form);
+    }
+    forgotPassword(form) {
+        return forgotPassword.bind(this)(form);
+    }
+    changePassword(params) { return changePassword.bind(this)(params); }
+    updateProfile(form) { return updateProfile.bind(this)(form); }
+    postRecord(form, config) { return postRecord.bind(this)(form, config); }
+    subscribe(option) {
+        return subscribe.bind(this)(option);
+    }
+    unsubscribe(option) {
+        return unsubscribe.bind(this)(option);
+    }
+    blockSubscriber(option) {
+        return blockSubscriber.bind(this)(option);
+    }
+    unblockSubscriber(option) {
+        return unblockSubscriber.bind(this)(option);
+    }
+    subscribeNewsletter(form) {
+        return subscribeNewsletter.bind(this)(form);
+    }
 }
 __decorate([
     formHandler()

package/js/methods/database.d.ts

@@ -1,15 +1,10 @@
 import { RecordData, Form, FormSubmitCallback, FetchOptions, DatabaseResponse, GetRecordQuery, Condition, PostRecordConfig, ProgressCallback } from '../Types';
 export declare function deleteFiles(params: {
-    service?: string;
     endpoints: string | string[];
-    storage?: 'records' | 'host';
-}): Promise<any>;
+}): Promise<RecordData[]>;
 export declare function uploadFiles(fileList: Form<FileList | File[]>, params: {
-    service?: string;
     record_id: string;
-    request?: 'post' | 'host';
-    progress: ProgressCallback;
-}): Promise<{
+} & FormSubmitCallback): Promise<{
     completed: File[];
     failed: File[];
 }>;
@@ -41,13 +36,13 @@ export declare function getIndexes(query: {
     table: string;
     index: string;
     number_of_records: number;
-    string_count: number;
-    number_count: number;
-    boolean_count: number;
-    total_number: number;
-    total_bool: number;
-    average_number: number;
-    average_bool: number;
+    string_count?: number;
+    number_count?: number;
+    boolean_count?: number;
+    total_number?: number;
+    total_bool?: number;
+    average_number?: number;
+    average_bool?: number;
 }>>;
 export declare function getTags(query: {
     table: string;
@@ -71,13 +66,13 @@ export declare function deleteRecords(params: {
 export declare function grantPrivateRecordAccess(params: {
     record_id: string;
     user_id: string | string[];
-}): Promise<void>;
+}): any;
 export declare function removePrivateRecordAccess(params: {
     record_id: string;
     user_id: string | string[];
-}): Promise<void>;
+}): any;
 export declare function listPrivateRecordAccess(params: {
     record_id: string;
     user_id: string | string[];
-}): Promise<void>;
-export declare function requestPrivateRecordAccessKey(record_id: string): Promise<void>;
+}): any;
+export declare function requestPrivateRecordAccessKey(record_id: string): any;