@query-farm/vgi 0.6.0

package/dist/functions/types.d.ts

@@ -0,0 +1,157 @@
+import type { VgiSchema, VgiBatch } from "../arrow/index.js";
+import type { OutputCollector } from "@query-farm/vgi-rpc";
+import type { FunctionStability, NullHandling, OrderPreservation, OrderDependence, DistinctDependence, TableCardinality } from "../types.js";
+import type { BindRequest, BindResponse, InitRequest, GlobalInitResponse, TableFunctionCardinalityRequest } from "../protocol/types.js";
+import type { ArgumentSpec } from "../arguments/argument-spec.js";
+/** Convention for handler state: mutable user state lives in `.state`. */
+export interface HandlerState<T = any> {
+    /** Serializable user state for HTTP exchange round-trips. */
+    state: T;
+    [key: string]: any;
+}
+export interface FunctionExample {
+    sql: string;
+    description: string;
+    expectedOutput?: string;
+}
+export interface FunctionMeta {
+    name: string;
+    description?: string;
+    stability?: FunctionStability;
+    nullHandling?: NullHandling;
+    examples?: FunctionExample[];
+    categories?: string[];
+    tags?: Record<string, string>;
+    projectionPushdown?: boolean;
+    filterPushdown?: boolean;
+    samplingPushdown?: boolean;
+    /**
+     * table (generator): opt in to DuckDB's late-materialization rewrite. A
+     * TOP_N/LIMIT/SAMPLE over a rowid-bearing table is rewritten into a SEMI
+     * join — a narrow ordering scan selects survivors, then the wide scan
+     * re-fetches their columns with the surviving rowids pushed down. Surfaces
+     * as FunctionInfo `late_materialization`. Only honoured by the C++ extension
+     * for tables whose worker also guarantees a UNIQUE, snapshot-stable rowid.
+     */
+    lateMaterialization?: boolean;
+    supportedExpressionFilters?: string[];
+    autoApplyFilters?: boolean;
+    preservesOrder?: OrderPreservation;
+    maxWorkers?: number;
+    requiredSettings?: string[];
+    requiredSecrets?: string[];
+    orderDependent?: OrderDependence;
+    distinctDependent?: DistinctDependence;
+    /**
+     * For table_in_out functions: whether the user defined a finalize callback.
+     * DuckDB issues a separate FINALIZE init() phase only when this is true;
+     * otherwise calling FinalExecute is unsupported and crashes the C++ side.
+     */
+    hasFinalize?: boolean;
+    /**
+     * table_buffering: force ParallelSink=false in the C++ operator
+     * (single-thread, source-ordered ingest).
+     */
+    sinkOrderDependent?: boolean;
+    /**
+     * table_buffering: force serial Source drain in finalize_queue order
+     * (ParallelSource=false, SourceOrder=FIXED_ORDER).
+     */
+    sourceOrderDependent?: boolean;
+    /**
+     * table_buffering: thread DuckDB's per-chunk batch_index into every
+     * process() call (RequiredPartitionInfo=BatchIndex).
+     */
+    requiresInputBatchIndex?: boolean;
+    /**
+     * table (generator): the function tags every emitted Arrow batch with a
+     * per-partition `vgi_batch_index` so DuckDB's ordered sinks reassemble
+     * parallel output in partition order. Surfaces as FunctionInfo
+     * `supports_batch_index`.
+     */
+    supportsBatchIndex?: boolean;
+    /**
+     * table (generator): Hive-style partition-columns mode. Functions declare
+     * a PartitionKind and annotate bind-schema fields; emitted batches carry
+     * `vgi_partition_values#b64` metadata. Surfaces as FunctionInfo
+     * `partition_kind`.
+     */
+    partitionKind?: "NOT_PARTITIONED" | "SINGLE_VALUE_PARTITIONS" | "OVERLAPPING_PARTITIONS" | "DISJOINT_PARTITIONS";
+    /**
+     * COPY ... FROM custom format reader: the SQL `FORMAT` identifier this
+     * function backs (e.g. `example_lines`). Set by {@link defineCopyFromFunction}.
+     * When present, the catalog advertises this function via
+     * `copyFromFormats()` / the `catalog_copy_from_formats` RPC so the VGI
+     * extension registers a DuckDB CopyFunction for it. Mirrors vgi-python's
+     * `CopyFromFunction.COPY_FROM_FORMAT`.
+     */
+    copyFromFormat?: string;
+    /** COPY direction; only `"from"` is supported today. Default `"from"`. */
+    copyFromDirection?: string;
+    /** Optional free-text comment surfaced by `vgi_copy_formats()`. */
+    copyFromComment?: string | null;
+    /**
+     * COPY ... TO custom format writer: the SQL `FORMAT` identifier this function
+     * backs (e.g. `example_lines_out`). Set by {@link defineCopyToFunction}. When
+     * present, the catalog advertises this function via `copyFromFormats()` (the
+     * `catalog_copy_from_formats` RPC returns all directions) so the VGI
+     * extension registers a DuckDB CopyFunction for it. The writer is a
+     * `table_buffering` function under the hood, reusing the
+     * `table_buffering_process` / `table_buffering_combine` RPCs. Mirrors
+     * vgi-python's `CopyToFunction.COPY_TO_FORMAT`.
+     */
+    copyToFormat?: string;
+    /** COPY direction for a TO writer; always `"to"`. Default `"to"`. */
+    copyToDirection?: string;
+    /** Optional free-text comment surfaced by `vgi_copy_formats()`. */
+    copyToComment?: string | null;
+}
+export interface StreamHandlers {
+    producerInit?: () => any;
+    producerFn?: (state: any, out: OutputCollector) => void | Promise<void>;
+    exchangeInit?: () => any;
+    exchangeFn?: (state: any, input: VgiBatch, out: OutputCollector) => void | Promise<void>;
+    outputSchema: VgiSchema;
+    inputSchema?: VgiSchema;
+    /**
+     * Fires once per tick batch on the producer path, before `producerFn`.
+     * Receives the tick's Arrow custom metadata so the handler can pick up
+     * per-tick signals like `vgi_pushdown_filters` (dynamic filter updates
+     * from DuckDB's Top-N optimizer).
+     */
+    onTick?: (state: any, tickMetadata: Map<string, string> | undefined) => void | Promise<void>;
+}
+/**
+ * A resolved, registered VGI function definition.
+ */
+export interface VgiFunction {
+    kind: "scalar" | "table" | "table_in_out" | "table_buffering";
+    meta: FunctionMeta;
+    argumentSpecs: ArgumentSpec[];
+    /** Default output schema (for catalog registration). May be overridden at bind time. */
+    defaultOutputSchema?: VgiSchema;
+    bind(request: BindRequest): BindResponse | Promise<BindResponse>;
+    globalInit(request: InitRequest): GlobalInitResponse | Promise<GlobalInitResponse>;
+    createStreamHandlers(request: InitRequest, response: GlobalInitResponse, accumulatedState?: any): StreamHandlers;
+    cardinality?(request: TableFunctionCardinalityRequest): TableCardinality | Promise<TableCardinality>;
+    /**
+     * Per-column statistics for this table function's output given the user's
+     * bind-time arguments. Returns null/[] when stats are unknown. Wired to the
+     * `table_function_statistics` RPC; DuckDB uses the bounds for plan-time
+     * filter elimination.
+     */
+    statistics?(request: TableFunctionCardinalityRequest): import("../util/statistics.js").ColumnStatistics[] | null;
+    /**
+     * Per-execution diagnostics for EXPLAIN ANALYZE. DuckDB calls this at
+     * pipeline FinishSource via the `table_function_dynamic_to_string` RPC.
+     * Returns ordered key→value strings; the C++ extension merges these with
+     * the intrinsic keys (Function, Rows Read, Threads).
+     */
+    dynamicToString?(request: DynamicToStringRequest): Record<string, string> | Promise<Record<string, string>>;
+}
+/** Request bundle for the `table_function_dynamic_to_string` RPC. */
+export interface DynamicToStringRequest {
+    bindCall: BindRequest;
+    bindOpaqueData: Uint8Array | null;
+    globalExecutionId: Uint8Array;
+}

package/dist/generated/vgi-client.d.ts

@@ -0,0 +1,466 @@
+export type DistinctDependence = "DISTINCT_DEPENDENT" | "NOT_DISTINCT_DEPENDENT";
+export type FunctionStability = "CONSISTENT" | "VOLATILE" | "CONSISTENT_WITHIN_QUERY";
+export type FunctionType = "SCALAR" | "TABLE" | "TABLE_BUFFERING" | "AGGREGATE";
+export type IndexConstraintType = "NONE" | "UNIQUE" | "PRIMARY";
+export type InvocationFunctionType = "AGGREGATE" | "SCALAR" | "TABLE" | "TABLE_BUFFERING";
+export type MacroType = "SCALAR" | "TABLE";
+export type NullHandling = "DEFAULT" | "SPECIAL";
+export type OnConflict = "ERROR" | "IGNORE" | "REPLACE";
+export type OrderByDirection = "ASC" | "DESC";
+export type OrderByNullOrder = "NULLS_FIRST" | "NULLS_LAST";
+export type OrderDependence = "ORDER_DEPENDENT" | "NOT_ORDER_DEPENDENT";
+export type OrderPreservation = "PRESERVES_ORDER" | "NO_ORDER_GUARANTEE" | "FIXED_ORDER";
+export type PartitionKind = "NOT_PARTITIONED" | "SINGLE_VALUE_PARTITIONS" | "OVERLAPPING_PARTITIONS" | "DISJOINT_PARTITIONS";
+export type SchemaObjectType = "TABLE" | "VIEW" | "SCALAR_FUNCTION" | "TABLE_FUNCTION" | "AGGREGATE_FUNCTION" | "SCALAR_MACRO" | "TABLE_MACRO" | "INDEX";
+export type TableInOutFunctionInitPhase = "INPUT" | "FINALIZE" | "TABLE_BUFFERING" | "TABLE_BUFFERING_FINALIZE";
+export interface CatalogDataVersionRelease {
+    version: string;
+    released_at?: bigint | null;
+    summary: string;
+    notes_url?: string | null;
+}
+export interface CatalogInfo {
+    name: string;
+    implementation_version?: string | null;
+    data_version_spec?: string | null;
+    attach_option_specs: Uint8Array[];
+    releases: CatalogDataVersionRelease[];
+    source_url?: string | null;
+}
+export interface SchemaInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    attach_opaque_data: Uint8Array;
+    name: string;
+    estimated_object_count?: Record<string, number> | null;
+}
+export interface TableInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    name: string;
+    schema_name: string;
+    columns: Uint8Array;
+    not_null_constraints: number[];
+    unique_constraints: number[][];
+    check_constraints: string[];
+    primary_key_constraints: number[][];
+    foreign_key_constraints: Uint8Array[];
+    supports_insert: boolean;
+    supports_update: boolean;
+    supports_delete: boolean;
+    supports_returning: boolean;
+    supports_column_statistics: boolean;
+    scan_function?: Uint8Array | null;
+    insert_function?: Uint8Array | null;
+    update_function?: Uint8Array | null;
+    delete_function?: Uint8Array | null;
+    cardinality_estimate?: number | null;
+    cardinality_max?: number | null;
+    column_statistics?: Uint8Array | null;
+    bind_result?: Uint8Array | null;
+    required_field_filter_paths: string[];
+}
+export interface ViewInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    name: string;
+    schema_name: string;
+    definition: string;
+    column_comments: Record<string, string>;
+}
+export interface CatalogExample {
+    sql: string;
+    description: string;
+    expected_output?: string | null;
+}
+export interface SecretLookupEntry {
+    secret_type: string;
+    scope?: string | null;
+    secret_name?: string | null;
+}
+export interface FunctionInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    name: string;
+    schema_name: string;
+    function_type: FunctionType;
+    arguments: Uint8Array;
+    output_schema: Uint8Array;
+    stability?: FunctionStability | null;
+    null_handling?: NullHandling | null;
+    description: string;
+    examples: CatalogExample[];
+    categories: string[];
+    projection_pushdown?: boolean | null;
+    filter_pushdown?: boolean | null;
+    sampling_pushdown?: boolean | null;
+    late_materialization?: boolean | null;
+    supported_expression_filters: string[];
+    order_preservation?: OrderPreservation | null;
+    max_workers?: number | null;
+    supports_batch_index: boolean;
+    partition_kind: PartitionKind;
+    order_dependent: OrderDependence;
+    distinct_dependent: DistinctDependence;
+    supports_window: boolean;
+    streaming_partitioned: boolean;
+    has_finalize: boolean;
+    source_order_dependent: boolean;
+    sink_order_dependent: boolean;
+    requires_input_batch_index: boolean;
+    required_settings: string[];
+    required_secrets: SecretLookupEntry[];
+}
+export interface MacroInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    name: string;
+    schema_name: string;
+    macro_type: MacroType;
+    parameters: string[];
+    parameter_default_values?: /** @record-batch */ Uint8Array | null;
+    definition: string;
+    arguments_schema?: /** @arrow-schema */ Uint8Array | null;
+}
+export interface IndexInfo {
+    comment?: string | null;
+    tags: Record<string, string>;
+    name: string;
+    schema_name: string;
+    table_name: string;
+    index_type: string;
+    constraint_type: IndexConstraintType;
+    expressions: string[];
+    options: Record<string, string>;
+}
+export interface AggregateBindRequest {
+    function_name: string;
+    arguments: Uint8Array;
+    input_schema?: /** @arrow-schema */ Uint8Array | null;
+    settings?: /** @record-batch */ Uint8Array | null;
+    secrets?: /** @record-batch */ Uint8Array | null;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateBindResponse {
+    output_schema: Uint8Array;
+    execution_id: Uint8Array;
+}
+export interface AggregateCombineRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    merge_batch: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateCombineResponse {
+}
+export interface AggregateDestructorRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    group_ids_batch: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateDestructorResponse {
+}
+export interface AggregateFinalizeRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    group_ids_batch: Uint8Array;
+    output_schema: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateFinalizeResponse {
+    result_batch: Uint8Array;
+}
+export interface AggregateStreamingChunkRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    input_batch: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateStreamingChunkResponse {
+    result_batch: Uint8Array;
+}
+export interface AggregateStreamingCloseRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateStreamingCloseResponse {
+}
+export interface AggregateStreamingOpenRequest {
+    function_name: string;
+    arguments: Uint8Array;
+    input_schema: Uint8Array;
+    partition_key_count: number;
+    order_key_count: number;
+    output_schema: Uint8Array;
+    settings?: /** @record-batch */ Uint8Array | null;
+    secrets?: /** @record-batch */ Uint8Array | null;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateStreamingOpenResponse {
+    execution_id: Uint8Array;
+}
+export interface AggregateUpdateRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    input_batch: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateUpdateResponse {
+}
+export interface AggregateWindowRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    partition_id: number;
+    rid: number;
+    frame_starts: number[];
+    frame_ends: number[];
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateWindowResponse {
+    result_batch: Uint8Array;
+}
+export interface AggregateWindowBatchRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    partition_id: number;
+    row_idx: number;
+    count: number;
+    frames_per_row: number[];
+    frame_starts: number[];
+    frame_ends: number[];
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateWindowBatchResponse {
+    result_batch: Uint8Array;
+}
+export interface AggregateWindowDestructorRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    partition_id: number;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateWindowDestructorResponse {
+}
+export interface AggregateWindowInitRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    partition_id: number;
+    row_count: number;
+    partition_batch: Uint8Array;
+    output_schema: Uint8Array;
+    filter_mask: Uint8Array;
+    frame_stats: Uint8Array;
+    all_valid: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+}
+export interface AggregateWindowInitResponse {
+}
+export interface CopyFromContext {
+    format: string;
+    file_path: string;
+    expected_schema: Uint8Array;
+}
+export interface CopyToContext {
+    format: string;
+    file_path: string;
+}
+export interface BindRequest {
+    function_name: string;
+    arguments: Uint8Array;
+    function_type: InvocationFunctionType;
+    input_schema?: /** @arrow-schema */ Uint8Array | null;
+    settings?: /** @record-batch */ Uint8Array | null;
+    secrets?: /** @record-batch */ Uint8Array | null;
+    attach_opaque_data?: Uint8Array | null;
+    transaction_opaque_data?: Uint8Array | null;
+    resolved_secrets_provided: boolean;
+    at_unit?: string | null;
+    at_value?: string | null;
+    copy_from?: CopyFromContext | null;
+    copy_to?: CopyToContext | null;
+}
+export interface BindResponse {
+    output_schema: Uint8Array;
+    opaque_data?: Uint8Array | null;
+    lookup_secret_types: string[];
+    lookup_scopes: string[];
+    lookup_names: string[];
+}
+export interface CatalogAttachRequest {
+    name: string;
+    options?: /** @record-batch */ Uint8Array | null;
+    data_version_spec?: string | null;
+    implementation_version?: string | null;
+}
+export interface CatalogAttachResult {
+    attach_opaque_data: Uint8Array;
+    supports_transactions: boolean;
+    supports_time_travel: boolean;
+    catalog_version_frozen: boolean;
+    catalog_version: number;
+    attach_opaque_data_required: boolean;
+    default_schema: string;
+    settings: Uint8Array[];
+    secret_types: Uint8Array[];
+    comment?: string | null;
+    tags: Record<string, string>;
+    supports_column_statistics: boolean;
+    resolved_data_version?: string | null;
+    resolved_implementation_version?: string | null;
+}
+export interface CatalogsResponse {
+    items: CatalogInfo[];
+}
+export interface CopyFromFormatsResponse {
+    items: Uint8Array[];
+}
+export interface CatalogCreateRequest {
+    name: string;
+    on_conflict: OnConflict;
+    options?: /** @record-batch */ Uint8Array | null;
+}
+export interface IndexCreateRequest {
+    attach_opaque_data: Uint8Array;
+    schema_name: string;
+    name: string;
+    table_name: string;
+    index_type: string;
+    constraint_type: IndexConstraintType;
+    expressions: string[];
+    on_conflict: OnConflict;
+    options: Record<string, string>;
+    transaction_opaque_data?: Uint8Array | null;
+}
+export interface IndexesResponse {
+    items: IndexInfo[];
+}
+export interface MacroCreateRequest {
+    attach_opaque_data: Uint8Array;
+    schema_name: string;
+    name: string;
+    macro_type: MacroType;
+    parameters: string[];
+    definition: string;
+    on_conflict: OnConflict;
+    parameter_default_values?: /** @record-batch */ Uint8Array | null;
+    arguments_schema?: /** @arrow-schema */ Uint8Array | null;
+    transaction_opaque_data?: Uint8Array | null;
+}
+export interface MacrosResponse {
+    items: MacroInfo[];
+}
+export interface FunctionsResponse {
+    items: FunctionInfo[];
+}
+export interface TablesResponse {
+    items: TableInfo[];
+}
+export interface ViewsResponse {
+    items: ViewInfo[];
+}
+export interface SchemasResponse {
+    items: SchemaInfo[];
+}
+export interface TableCreateRequest {
+    attach_opaque_data: Uint8Array;
+    schema_name: string;
+    name: string;
+    columns: Uint8Array;
+    on_conflict: OnConflict;
+    not_null_constraints: number[];
+    unique_constraints: number[][];
+    check_constraints: string[];
+    primary_key_constraints: number[][];
+    foreign_key_constraints: Uint8Array[];
+    transaction_opaque_data?: Uint8Array | null;
+}
+export interface TransactionBeginResponse {
+    transaction_opaque_data?: Uint8Array | null;
+}
+export interface CatalogVersionResponse {
+    version: number;
+}
+export interface InitRequest {
+    bind_call: BindRequest;
+    output_schema: Uint8Array;
+    bind_opaque_data?: Uint8Array | null;
+    projection_ids?: number[] | null;
+    pushdown_filters?: /** @record-batch */ Uint8Array | null;
+    join_keys?: /** @record-batch */ Uint8Array[] | null;
+    phase?: TableInOutFunctionInitPhase | null;
+    finalize_state_id?: Uint8Array | null;
+    execution_id?: Uint8Array | null;
+    init_opaque_data?: Uint8Array | null;
+    order_by_column_name?: string | null;
+    order_by_direction?: OrderByDirection | null;
+    order_by_null_order?: OrderByNullOrder | null;
+    order_by_limit?: number | null;
+    tablesample_percentage?: number | null;
+    tablesample_seed?: number | null;
+}
+export interface TableBufferingCombineRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    state_ids: Uint8Array[];
+    attach_opaque_data?: Uint8Array | null;
+    transaction_id?: Uint8Array | null;
+}
+export interface TableBufferingCombineResponse {
+    finalize_state_ids: Uint8Array[];
+}
+export interface TableBufferingDestructorRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+    transaction_id?: Uint8Array | null;
+}
+export interface TableBufferingDestructorResponse {
+}
+export interface TableBufferingProcessRequest {
+    function_name: string;
+    execution_id: Uint8Array;
+    input_batch: Uint8Array;
+    attach_opaque_data?: Uint8Array | null;
+    transaction_id?: Uint8Array | null;
+    batch_index?: number | null;
+}
+export interface TableBufferingProcessResponse {
+    state_id: Uint8Array;
+}
+export interface TableFunctionCardinalityRequest {
+    bind_call: BindRequest;
+    bind_opaque_data?: Uint8Array | null;
+}
+export interface TableCardinality {
+    estimate?: number | null;
+    max?: number | null;
+}
+export interface TableFunctionDynamicToStringRequest {
+    bind_call: BindRequest;
+    bind_opaque_data?: Uint8Array | null;
+    global_execution_id: Uint8Array;
+}
+export interface TableFunctionDynamicToStringResponse {
+    keys: string[];
+    values: string[];
+}
+export interface TableFunctionStatisticsRequest {
+    bind_call: BindRequest;
+    bind_opaque_data?: Uint8Array | null;
+}
+export declare const encodeCatalogInfo: (v: CatalogInfo) => Uint8Array;
+export declare const decodeCatalogInfo: (b: Uint8Array) => CatalogInfo;
+export declare const encodeFunctionInfo: (v: FunctionInfo) => Uint8Array;
+export declare const decodeFunctionInfo: (b: Uint8Array) => FunctionInfo;
+export declare const encodeIndexInfo: (v: IndexInfo) => Uint8Array;
+export declare const decodeIndexInfo: (b: Uint8Array) => IndexInfo;
+export declare const encodeMacroInfo: (v: MacroInfo) => Uint8Array;
+export declare const decodeMacroInfo: (b: Uint8Array) => MacroInfo;
+export declare const encodeSchemaInfo: (v: SchemaInfo) => Uint8Array;
+export declare const decodeSchemaInfo: (b: Uint8Array) => SchemaInfo;
+export declare const encodeTableInfo: (v: TableInfo) => Uint8Array;
+export declare const decodeTableInfo: (b: Uint8Array) => TableInfo;
+export declare const encodeViewInfo: (v: ViewInfo) => Uint8Array;
+export declare const decodeViewInfo: (b: Uint8Array) => ViewInfo;