// package: co.treelab.api
// file: service.proto

/* tslint:disable */

import * as jspb from "google-protobuf";

export class EmptyInput extends jspb.Message { 

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EmptyInput.AsObject;
    static toObject(includeInstance: boolean, msg: EmptyInput): EmptyInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EmptyInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EmptyInput;
    static deserializeBinaryFromReader(message: EmptyInput, reader: jspb.BinaryReader): EmptyInput;
}

export namespace EmptyInput {
    export type AsObject = {
    }
}

export class WorkspacesResult extends jspb.Message { 
    clearResultList(): void;
    getResultList(): Array<WorkspaceProjection>;
    setResultList(value: Array<WorkspaceProjection>): void;
    addResult(value?: WorkspaceProjection, index?: number): WorkspaceProjection;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): WorkspacesResult.AsObject;
    static toObject(includeInstance: boolean, msg: WorkspacesResult): WorkspacesResult.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: WorkspacesResult, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): WorkspacesResult;
    static deserializeBinaryFromReader(message: WorkspacesResult, reader: jspb.BinaryReader): WorkspacesResult;
}

export namespace WorkspacesResult {
    export type AsObject = {
        resultList: Array<WorkspaceProjection.AsObject>,
    }
}

export class CoresResult extends jspb.Message { 
    clearResultList(): void;
    getResultList(): Array<CoreProjection>;
    setResultList(value: Array<CoreProjection>): void;
    addResult(value?: CoreProjection, index?: number): CoreProjection;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CoresResult.AsObject;
    static toObject(includeInstance: boolean, msg: CoresResult): CoresResult.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CoresResult, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CoresResult;
    static deserializeBinaryFromReader(message: CoresResult, reader: jspb.BinaryReader): CoresResult;
}

export namespace CoresResult {
    export type AsObject = {
        resultList: Array<CoreProjection.AsObject>,
    }
}

export class TablesResult extends jspb.Message { 
    clearResultList(): void;
    getResultList(): Array<TableProjection>;
    setResultList(value: Array<TableProjection>): void;
    addResult(value?: TableProjection, index?: number): TableProjection;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TablesResult.AsObject;
    static toObject(includeInstance: boolean, msg: TablesResult): TablesResult.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TablesResult, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TablesResult;
    static deserializeBinaryFromReader(message: TablesResult, reader: jspb.BinaryReader): TablesResult;
}

export namespace TablesResult {
    export type AsObject = {
        resultList: Array<TableProjection.AsObject>,
    }
}

export class TableProjection extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getName(): string;
    setName(value: string): void;

    clearViewsList(): void;
    getViewsList(): Array<ViewData>;
    setViewsList(value: Array<ViewData>): void;
    addViews(value?: ViewData, index?: number): ViewData;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TableProjection.AsObject;
    static toObject(includeInstance: boolean, msg: TableProjection): TableProjection.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TableProjection, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TableProjection;
    static deserializeBinaryFromReader(message: TableProjection, reader: jspb.BinaryReader): TableProjection;
}

export namespace TableProjection {
    export type AsObject = {
        id: string,
        name: string,
        viewsList: Array<ViewData.AsObject>,
    }
}

export class TableData extends jspb.Message { 
    clearRowsList(): void;
    getRowsList(): Array<RowData>;
    setRowsList(value: Array<RowData>): void;
    addRows(value?: RowData, index?: number): RowData;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TableData.AsObject;
    static toObject(includeInstance: boolean, msg: TableData): TableData.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TableData, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TableData;
    static deserializeBinaryFromReader(message: TableData, reader: jspb.BinaryReader): TableData;
}

export namespace TableData {
    export type AsObject = {
        rowsList: Array<RowData.AsObject>,
    }
}

export class RowData extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getOrder(): number;
    setOrder(value: number): void;

    clearCellsList(): void;
    getCellsList(): Array<CellData>;
    setCellsList(value: Array<CellData>): void;
    addCells(value?: CellData, index?: number): CellData;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RowData.AsObject;
    static toObject(includeInstance: boolean, msg: RowData): RowData.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RowData, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RowData;
    static deserializeBinaryFromReader(message: RowData, reader: jspb.BinaryReader): RowData;
}

export namespace RowData {
    export type AsObject = {
        id: string,
        order: number,
        cellsList: Array<CellData.AsObject>,
    }
}

export class CellData extends jspb.Message { 
    getColumnid(): string;
    setColumnid(value: string): void;

    getType(): string;
    setType(value: string): void;

    getText(): string;
    setText(value: string): void;

    clearForeignrowList(): void;
    getForeignrowList(): Array<ForeignRowValue>;
    setForeignrowList(value: Array<ForeignRowValue>): void;
    addForeignrow(value?: ForeignRowValue, index?: number): ForeignRowValue;

    getNumber(): number;
    setNumber(value: number): void;


    hasSelecteditem(): boolean;
    clearSelecteditem(): void;
    getSelecteditem(): Choice | undefined;
    setSelecteditem(value?: Choice): void;

    clearSelecteditemsList(): void;
    getSelecteditemsList(): Array<Choice>;
    setSelecteditemsList(value: Array<Choice>): void;
    addSelecteditems(value?: Choice, index?: number): Choice;

    clearAttachmentsList(): void;
    getAttachmentsList(): Array<Attachment>;
    setAttachmentsList(value: Array<Attachment>): void;
    addAttachments(value?: Attachment, index?: number): Attachment;

    getDatetime(): string;
    setDatetime(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CellData.AsObject;
    static toObject(includeInstance: boolean, msg: CellData): CellData.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CellData, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CellData;
    static deserializeBinaryFromReader(message: CellData, reader: jspb.BinaryReader): CellData;
}

export namespace CellData {
    export type AsObject = {
        columnid: string,
        type: string,
        text: string,
        foreignrowList: Array<ForeignRowValue.AsObject>,
        number: number,
        selecteditem?: Choice.AsObject,
        selecteditemsList: Array<Choice.AsObject>,
        attachmentsList: Array<Attachment.AsObject>,
        datetime: string,
    }
}

export class ViewData extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getType(): string;
    setType(value: string): void;

    getName(): string;
    setName(value: string): void;

    clearRowsList(): void;
    getRowsList(): Array<RowData>;
    setRowsList(value: Array<RowData>): void;
    addRows(value?: RowData, index?: number): RowData;

    clearColumnsList(): void;
    getColumnsList(): Array<ColumnDefinition>;
    setColumnsList(value: Array<ColumnDefinition>): void;
    addColumns(value?: ColumnDefinition, index?: number): ColumnDefinition;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ViewData.AsObject;
    static toObject(includeInstance: boolean, msg: ViewData): ViewData.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ViewData, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ViewData;
    static deserializeBinaryFromReader(message: ViewData, reader: jspb.BinaryReader): ViewData;
}

export namespace ViewData {
    export type AsObject = {
        id: string,
        type: string,
        name: string,
        rowsList: Array<RowData.AsObject>,
        columnsList: Array<ColumnDefinition.AsObject>,
    }
}

export class ColumnDefinition extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getType(): string;
    setType(value: string): void;

    getName(): string;
    setName(value: string): void;

    getOrder(): number;
    setOrder(value: number): void;

    getVisibility(): boolean;
    setVisibility(value: boolean): void;

    getForeigntableid(): string;
    setForeigntableid(value: string): void;

    getDefaultnumber(): number;
    setDefaultnumber(value: number): void;

    getPrecision(): number;
    setPrecision(value: number): void;

    clearChoicesList(): void;
    getChoicesList(): Array<Choice>;
    setChoicesList(value: Array<Choice>): void;
    addChoices(value?: Choice, index?: number): Choice;

    getDateformat(): string;
    setDateformat(value: string): void;

    getIncludetime(): boolean;
    setIncludetime(value: boolean): void;

    getTimeformat(): string;
    setTimeformat(value: string): void;

    getUsegmt(): boolean;
    setUsegmt(value: boolean): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ColumnDefinition.AsObject;
    static toObject(includeInstance: boolean, msg: ColumnDefinition): ColumnDefinition.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ColumnDefinition, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ColumnDefinition;
    static deserializeBinaryFromReader(message: ColumnDefinition, reader: jspb.BinaryReader): ColumnDefinition;
}

export namespace ColumnDefinition {
    export type AsObject = {
        id: string,
        type: string,
        name: string,
        order: number,
        visibility: boolean,
        foreigntableid: string,
        defaultnumber: number,
        precision: number,
        choicesList: Array<Choice.AsObject>,
        dateformat: string,
        includetime: boolean,
        timeformat: string,
        usegmt: boolean,
    }
}

export class Choice extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getName(): string;
    setName(value: string): void;

    getColor(): string;
    setColor(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Choice.AsObject;
    static toObject(includeInstance: boolean, msg: Choice): Choice.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Choice, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Choice;
    static deserializeBinaryFromReader(message: Choice, reader: jspb.BinaryReader): Choice;
}

export namespace Choice {
    export type AsObject = {
        id: string,
        name: string,
        color: string,
    }
}

export class WorkspaceProjection extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getName(): string;
    setName(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): WorkspaceProjection.AsObject;
    static toObject(includeInstance: boolean, msg: WorkspaceProjection): WorkspaceProjection.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: WorkspaceProjection, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): WorkspaceProjection;
    static deserializeBinaryFromReader(message: WorkspaceProjection, reader: jspb.BinaryReader): WorkspaceProjection;
}

export namespace WorkspaceProjection {
    export type AsObject = {
        id: string,
        name: string,
    }
}

export class CoreProjection extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getName(): string;
    setName(value: string): void;

    getColor(): string;
    setColor(value: string): void;

    getIcon(): string;
    setIcon(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CoreProjection.AsObject;
    static toObject(includeInstance: boolean, msg: CoreProjection): CoreProjection.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CoreProjection, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CoreProjection;
    static deserializeBinaryFromReader(message: CoreProjection, reader: jspb.BinaryReader): CoreProjection;
}

export namespace CoreProjection {
    export type AsObject = {
        id: string,
        name: string,
        color: string,
        icon: string,
    }
}

export class ForeignRowVisibleNameValue extends jspb.Message { 
    getValue(): string;
    setValue(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ForeignRowVisibleNameValue.AsObject;
    static toObject(includeInstance: boolean, msg: ForeignRowVisibleNameValue): ForeignRowVisibleNameValue.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ForeignRowVisibleNameValue, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ForeignRowVisibleNameValue;
    static deserializeBinaryFromReader(message: ForeignRowVisibleNameValue, reader: jspb.BinaryReader): ForeignRowVisibleNameValue;
}

export namespace ForeignRowVisibleNameValue {
    export type AsObject = {
        value: string,
    }
}

export class ForeignRowValue extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    clearVisiblenameList(): void;
    getVisiblenameList(): Array<ForeignRowVisibleNameValue>;
    setVisiblenameList(value: Array<ForeignRowVisibleNameValue>): void;
    addVisiblename(value?: ForeignRowVisibleNameValue, index?: number): ForeignRowVisibleNameValue;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ForeignRowValue.AsObject;
    static toObject(includeInstance: boolean, msg: ForeignRowValue): ForeignRowValue.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ForeignRowValue, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ForeignRowValue;
    static deserializeBinaryFromReader(message: ForeignRowValue, reader: jspb.BinaryReader): ForeignRowValue;
}

export namespace ForeignRowValue {
    export type AsObject = {
        id: string,
        visiblenameList: Array<ForeignRowVisibleNameValue.AsObject>,
    }
}

export class Attachment extends jspb.Message { 
    getName(): string;
    setName(value: string): void;

    getUrl(): string;
    setUrl(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Attachment.AsObject;
    static toObject(includeInstance: boolean, msg: Attachment): Attachment.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Attachment, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Attachment;
    static deserializeBinaryFromReader(message: Attachment, reader: jspb.BinaryReader): Attachment;
}

export namespace Attachment {
    export type AsObject = {
        name: string,
        url: string,
    }
}

export class ColumnConfig extends jspb.Message { 
    getName(): string;
    setName(value: string): void;

    getType(): string;
    setType(value: string): void;

    getOrder(): number;
    setOrder(value: number): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ColumnConfig.AsObject;
    static toObject(includeInstance: boolean, msg: ColumnConfig): ColumnConfig.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ColumnConfig, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ColumnConfig;
    static deserializeBinaryFromReader(message: ColumnConfig, reader: jspb.BinaryReader): ColumnConfig;
}

export namespace ColumnConfig {
    export type AsObject = {
        name: string,
        type: string,
        order: number,
    }
}

export class ViewDefinition extends jspb.Message { 
    getId(): string;
    setId(value: string): void;

    getName(): string;
    setName(value: string): void;

    getType(): string;
    setType(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ViewDefinition.AsObject;
    static toObject(includeInstance: boolean, msg: ViewDefinition): ViewDefinition.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ViewDefinition, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ViewDefinition;
    static deserializeBinaryFromReader(message: ViewDefinition, reader: jspb.BinaryReader): ViewDefinition;
}

export namespace ViewDefinition {
    export type AsObject = {
        id: string,
        name: string,
        type: string,
    }
}

export class EventMetadata extends jspb.Message { 
    getSource(): string;
    setSource(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EventMetadata.AsObject;
    static toObject(includeInstance: boolean, msg: EventMetadata): EventMetadata.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EventMetadata, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EventMetadata;
    static deserializeBinaryFromReader(message: EventMetadata, reader: jspb.BinaryReader): EventMetadata;
}

export namespace EventMetadata {
    export type AsObject = {
        source: string,
    }
}

export class EventPayload extends jspb.Message { 
    getEventname(): string;
    setEventname(value: string): void;

    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;

    getColumnid(): string;
    setColumnid(value: string): void;

    getRowid(): string;
    setRowid(value: string): void;

    getCorename(): string;
    setCorename(value: string): void;

    getColor(): string;
    setColor(value: string): void;

    getIcon(): string;
    setIcon(value: string): void;

    getTablename(): string;
    setTablename(value: string): void;


    hasColumnconfig(): boolean;
    clearColumnconfig(): void;
    getColumnconfig(): ColumnConfig | undefined;
    setColumnconfig(value?: ColumnConfig): void;


    hasView(): boolean;
    clearView(): void;
    getView(): ViewDefinition | undefined;
    setView(value?: ViewDefinition): void;


    hasAction(): boolean;
    clearAction(): void;
    getAction(): UpdateCellActionInput | undefined;
    setAction(value?: UpdateCellActionInput): void;


    hasMetadata(): boolean;
    clearMetadata(): void;
    getMetadata(): EventMetadata | undefined;
    setMetadata(value?: EventMetadata): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EventPayload.AsObject;
    static toObject(includeInstance: boolean, msg: EventPayload): EventPayload.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EventPayload, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EventPayload;
    static deserializeBinaryFromReader(message: EventPayload, reader: jspb.BinaryReader): EventPayload;
}

export namespace EventPayload {
    export type AsObject = {
        eventname: string,
        workspaceid: string,
        coreid: string,
        tableid: string,
        columnid: string,
        rowid: string,
        corename: string,
        color: string,
        icon: string,
        tablename: string,
        columnconfig?: ColumnConfig.AsObject,
        view?: ViewDefinition.AsObject,
        action?: UpdateCellActionInput.AsObject,
        Metadata?: EventMetadata.AsObject,
    }
}

export class WorkspaceSubscriptionInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getTopic(): string;
    setTopic(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): WorkspaceSubscriptionInput.AsObject;
    static toObject(includeInstance: boolean, msg: WorkspaceSubscriptionInput): WorkspaceSubscriptionInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: WorkspaceSubscriptionInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): WorkspaceSubscriptionInput;
    static deserializeBinaryFromReader(message: WorkspaceSubscriptionInput, reader: jspb.BinaryReader): WorkspaceSubscriptionInput;
}

export namespace WorkspaceSubscriptionInput {
    export type AsObject = {
        workspaceid: string,
        topic: string,
    }
}

export class ViewDefinitionInput extends jspb.Message { 
    getName(): string;
    setName(value: string): void;

    getType(): string;
    setType(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ViewDefinitionInput.AsObject;
    static toObject(includeInstance: boolean, msg: ViewDefinitionInput): ViewDefinitionInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ViewDefinitionInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ViewDefinitionInput;
    static deserializeBinaryFromReader(message: ViewDefinitionInput, reader: jspb.BinaryReader): ViewDefinitionInput;
}

export namespace ViewDefinitionInput {
    export type AsObject = {
        name: string,
        type: string,
    }
}

export class AddViewInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;


    hasView(): boolean;
    clearView(): void;
    getView(): ViewDefinitionInput | undefined;
    setView(value?: ViewDefinitionInput): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddViewInput.AsObject;
    static toObject(includeInstance: boolean, msg: AddViewInput): AddViewInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddViewInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddViewInput;
    static deserializeBinaryFromReader(message: AddViewInput, reader: jspb.BinaryReader): AddViewInput;
}

export namespace AddViewInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tableid: string,
        view?: ViewDefinitionInput.AsObject,
    }
}

export class AddColumnInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;


    hasColumnconfig(): boolean;
    clearColumnconfig(): void;
    getColumnconfig(): ColumnConfigInput | undefined;
    setColumnconfig(value?: ColumnConfigInput): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddColumnInput.AsObject;
    static toObject(includeInstance: boolean, msg: AddColumnInput): AddColumnInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddColumnInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddColumnInput;
    static deserializeBinaryFromReader(message: AddColumnInput, reader: jspb.BinaryReader): AddColumnInput;
}

export namespace AddColumnInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tableid: string,
        columnconfig?: ColumnConfigInput.AsObject,
    }
}

export class ColumnConfigInput extends jspb.Message { 
    getType(): string;
    setType(value: string): void;

    getName(): string;
    setName(value: string): void;

    getOrder(): number;
    setOrder(value: number): void;

    getForeigntableid(): string;
    setForeigntableid(value: string): void;

    getDefaultnumber(): number;
    setDefaultnumber(value: number): void;

    getPrecision(): number;
    setPrecision(value: number): void;

    clearChoicesList(): void;
    getChoicesList(): Array<Choice>;
    setChoicesList(value: Array<Choice>): void;
    addChoices(value?: Choice, index?: number): Choice;

    getDateformat(): string;
    setDateformat(value: string): void;

    getIncludetime(): boolean;
    setIncludetime(value: boolean): void;

    getTimeformat(): string;
    setTimeformat(value: string): void;

    getUsegmt(): boolean;
    setUsegmt(value: boolean): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ColumnConfigInput.AsObject;
    static toObject(includeInstance: boolean, msg: ColumnConfigInput): ColumnConfigInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ColumnConfigInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ColumnConfigInput;
    static deserializeBinaryFromReader(message: ColumnConfigInput, reader: jspb.BinaryReader): ColumnConfigInput;
}

export namespace ColumnConfigInput {
    export type AsObject = {
        type: string,
        name: string,
        order: number,
        foreigntableid: string,
        defaultnumber: number,
        precision: number,
        choicesList: Array<Choice.AsObject>,
        dateformat: string,
        includetime: boolean,
        timeformat: string,
        usegmt: boolean,
    }
}

export class AddRowInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddRowInput.AsObject;
    static toObject(includeInstance: boolean, msg: AddRowInput): AddRowInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddRowInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddRowInput;
    static deserializeBinaryFromReader(message: AddRowInput, reader: jspb.BinaryReader): AddRowInput;
}

export namespace AddRowInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tableid: string,
    }
}

export class CellValueInput extends jspb.Message { 
    getType(): string;
    setType(value: string): void;

    getText(): string;
    setText(value: string): void;

    getForeignrowid(): string;
    setForeignrowid(value: string): void;

    getNumber(): number;
    setNumber(value: number): void;


    hasSelecteditem(): boolean;
    clearSelecteditem(): void;
    getSelecteditem(): Choice | undefined;
    setSelecteditem(value?: Choice): void;

    clearSelecteditemsList(): void;
    getSelecteditemsList(): Array<Choice>;
    setSelecteditemsList(value: Array<Choice>): void;
    addSelecteditems(value?: Choice, index?: number): Choice;

    clearAttachmentsList(): void;
    getAttachmentsList(): Array<Attachment>;
    setAttachmentsList(value: Array<Attachment>): void;
    addAttachments(value?: Attachment, index?: number): Attachment;

    getDatetime(): string;
    setDatetime(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CellValueInput.AsObject;
    static toObject(includeInstance: boolean, msg: CellValueInput): CellValueInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CellValueInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CellValueInput;
    static deserializeBinaryFromReader(message: CellValueInput, reader: jspb.BinaryReader): CellValueInput;
}

export namespace CellValueInput {
    export type AsObject = {
        type: string,
        text: string,
        foreignrowid: string,
        number: number,
        selecteditem?: Choice.AsObject,
        selecteditemsList: Array<Choice.AsObject>,
        attachmentsList: Array<Attachment.AsObject>,
        datetime: string,
    }
}

export class UpdateCellActionInput extends jspb.Message { 
    getType(): string;
    setType(value: string): void;


    hasValue(): boolean;
    clearValue(): void;
    getValue(): CellValueInput | undefined;
    setValue(value?: CellValueInput): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): UpdateCellActionInput.AsObject;
    static toObject(includeInstance: boolean, msg: UpdateCellActionInput): UpdateCellActionInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: UpdateCellActionInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): UpdateCellActionInput;
    static deserializeBinaryFromReader(message: UpdateCellActionInput, reader: jspb.BinaryReader): UpdateCellActionInput;
}

export namespace UpdateCellActionInput {
    export type AsObject = {
        type: string,
        value?: CellValueInput.AsObject,
    }
}

export class UpdateCellInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;

    getColumnid(): string;
    setColumnid(value: string): void;

    getRowid(): string;
    setRowid(value: string): void;


    hasAction(): boolean;
    clearAction(): void;
    getAction(): UpdateCellActionInput | undefined;
    setAction(value?: UpdateCellActionInput): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): UpdateCellInput.AsObject;
    static toObject(includeInstance: boolean, msg: UpdateCellInput): UpdateCellInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: UpdateCellInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): UpdateCellInput;
    static deserializeBinaryFromReader(message: UpdateCellInput, reader: jspb.BinaryReader): UpdateCellInput;
}

export namespace UpdateCellInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tableid: string,
        columnid: string,
        rowid: string,
        action?: UpdateCellActionInput.AsObject,
    }
}

export class CreateWorkspaceInput extends jspb.Message { 
    getName(): string;
    setName(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CreateWorkspaceInput.AsObject;
    static toObject(includeInstance: boolean, msg: CreateWorkspaceInput): CreateWorkspaceInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CreateWorkspaceInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CreateWorkspaceInput;
    static deserializeBinaryFromReader(message: CreateWorkspaceInput, reader: jspb.BinaryReader): CreateWorkspaceInput;
}

export namespace CreateWorkspaceInput {
    export type AsObject = {
        name: string,
    }
}

export class AddCoreInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCorename(): string;
    setCorename(value: string): void;

    getColor(): string;
    setColor(value: string): void;

    getIcon(): string;
    setIcon(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddCoreInput.AsObject;
    static toObject(includeInstance: boolean, msg: AddCoreInput): AddCoreInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddCoreInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddCoreInput;
    static deserializeBinaryFromReader(message: AddCoreInput, reader: jspb.BinaryReader): AddCoreInput;
}

export namespace AddCoreInput {
    export type AsObject = {
        workspaceid: string,
        corename: string,
        color: string,
        icon: string,
    }
}

export class UpdateCoreInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getCorename(): string;
    setCorename(value: string): void;

    getColor(): string;
    setColor(value: string): void;

    getIcon(): string;
    setIcon(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): UpdateCoreInput.AsObject;
    static toObject(includeInstance: boolean, msg: UpdateCoreInput): UpdateCoreInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: UpdateCoreInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): UpdateCoreInput;
    static deserializeBinaryFromReader(message: UpdateCoreInput, reader: jspb.BinaryReader): UpdateCoreInput;
}

export namespace UpdateCoreInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        corename: string,
        color: string,
        icon: string,
    }
}

export class RemoveCoreInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RemoveCoreInput.AsObject;
    static toObject(includeInstance: boolean, msg: RemoveCoreInput): RemoveCoreInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RemoveCoreInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RemoveCoreInput;
    static deserializeBinaryFromReader(message: RemoveCoreInput, reader: jspb.BinaryReader): RemoveCoreInput;
}

export namespace RemoveCoreInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
    }
}

export class AddTableInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTablename(): string;
    setTablename(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AddTableInput.AsObject;
    static toObject(includeInstance: boolean, msg: AddTableInput): AddTableInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AddTableInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AddTableInput;
    static deserializeBinaryFromReader(message: AddTableInput, reader: jspb.BinaryReader): AddTableInput;
}

export namespace AddTableInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tablename: string,
    }
}

export class GetTableInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;

    getTableid(): string;
    setTableid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GetTableInput.AsObject;
    static toObject(includeInstance: boolean, msg: GetTableInput): GetTableInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GetTableInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GetTableInput;
    static deserializeBinaryFromReader(message: GetTableInput, reader: jspb.BinaryReader): GetTableInput;
}

export namespace GetTableInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
        tableid: string,
    }
}

export class GetWorkspaceInput extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GetWorkspaceInput.AsObject;
    static toObject(includeInstance: boolean, msg: GetWorkspaceInput): GetWorkspaceInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GetWorkspaceInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GetWorkspaceInput;
    static deserializeBinaryFromReader(message: GetWorkspaceInput, reader: jspb.BinaryReader): GetWorkspaceInput;
}

export namespace GetWorkspaceInput {
    export type AsObject = {
        id: string,
    }
}

export class GetCoreInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GetCoreInput.AsObject;
    static toObject(includeInstance: boolean, msg: GetCoreInput): GetCoreInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GetCoreInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GetCoreInput;
    static deserializeBinaryFromReader(message: GetCoreInput, reader: jspb.BinaryReader): GetCoreInput;
}

export namespace GetCoreInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
    }
}

export class GetCoresInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GetCoresInput.AsObject;
    static toObject(includeInstance: boolean, msg: GetCoresInput): GetCoresInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GetCoresInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GetCoresInput;
    static deserializeBinaryFromReader(message: GetCoresInput, reader: jspb.BinaryReader): GetCoresInput;
}

export namespace GetCoresInput {
    export type AsObject = {
        workspaceid: string,
    }
}

export class GetTablesInput extends jspb.Message { 
    getWorkspaceid(): string;
    setWorkspaceid(value: string): void;

    getCoreid(): string;
    setCoreid(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): GetTablesInput.AsObject;
    static toObject(includeInstance: boolean, msg: GetTablesInput): GetTablesInput.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: GetTablesInput, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): GetTablesInput;
    static deserializeBinaryFromReader(message: GetTablesInput, reader: jspb.BinaryReader): GetTablesInput;
}

export namespace GetTablesInput {
    export type AsObject = {
        workspaceid: string,
        coreid: string,
    }
}

export class WorkspaceId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): WorkspaceId.AsObject;
    static toObject(includeInstance: boolean, msg: WorkspaceId): WorkspaceId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: WorkspaceId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): WorkspaceId;
    static deserializeBinaryFromReader(message: WorkspaceId, reader: jspb.BinaryReader): WorkspaceId;
}

export namespace WorkspaceId {
    export type AsObject = {
        id: string,
    }
}

export class CoreId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): CoreId.AsObject;
    static toObject(includeInstance: boolean, msg: CoreId): CoreId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: CoreId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): CoreId;
    static deserializeBinaryFromReader(message: CoreId, reader: jspb.BinaryReader): CoreId;
}

export namespace CoreId {
    export type AsObject = {
        id: string,
    }
}

export class TableId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TableId.AsObject;
    static toObject(includeInstance: boolean, msg: TableId): TableId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TableId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TableId;
    static deserializeBinaryFromReader(message: TableId, reader: jspb.BinaryReader): TableId;
}

export namespace TableId {
    export type AsObject = {
        id: string,
    }
}

export class ColumnId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ColumnId.AsObject;
    static toObject(includeInstance: boolean, msg: ColumnId): ColumnId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ColumnId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ColumnId;
    static deserializeBinaryFromReader(message: ColumnId, reader: jspb.BinaryReader): ColumnId;
}

export namespace ColumnId {
    export type AsObject = {
        id: string,
    }
}

export class RowId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RowId.AsObject;
    static toObject(includeInstance: boolean, msg: RowId): RowId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RowId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RowId;
    static deserializeBinaryFromReader(message: RowId, reader: jspb.BinaryReader): RowId;
}

export namespace RowId {
    export type AsObject = {
        id: string,
    }
}

export class ViewId extends jspb.Message { 
    getId(): string;
    setId(value: string): void;


    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ViewId.AsObject;
    static toObject(includeInstance: boolean, msg: ViewId): ViewId.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ViewId, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ViewId;
    static deserializeBinaryFromReader(message: ViewId, reader: jspb.BinaryReader): ViewId;
}

export namespace ViewId {
    export type AsObject = {
        id: string,
    }
}