@ceramicnetwork/common/lib/stream.d.ts

Ceramic common types and utilities

import type { CID } from 'multiformats/cid';
import { StreamID } from '@ceramicnetwork/streamid';
import { CommitID } from '@ceramicnetwork/streamid';
import type { DagJWS, DagJWSResult } from 'dids';
import { Observable } from 'rxjs';
import type { RunningStateLike } from './running-state-like.js';
import { LoadOpts } from './streamopts.js';
import type { Cacao } from '@didtools/cacao';
import { NonEmptyArray } from './non-empty-array.js';
import type { AnchorProof, AnchorStatus } from './anchor-service.js';
import { StreamReaderWriter } from './ceramic-api.js';
export { AnchorStatus } from './anchor-service.js';
export declare enum SignatureStatus {
    GENESIS = 0,
    PARTIAL = 1,
    SIGNED = 2
}
export interface CommitHeader {
    controllers: Array<string>;
    family?: string;
    model?: Uint8Array;
    schema?: string;
    tags?: Array<string>;
    shouldIndex?: boolean;
    [index: string]: any;
}
export interface GenesisHeader extends CommitHeader {
    unique?: Uint8Array | string;
    context?: Uint8Array;
    forbidControllerChange?: boolean;
}
export declare type GenesisCommit = {
    header: GenesisHeader;
    data?: any;
};
export interface RawCommit {
    id: CID;
    header?: Partial<CommitHeader>;
    data: any;
    prev: CID;
}
export interface AnchorCommit {
    id: CID;
    prev: CID;
    proof: CID;
    path: string;
}
export declare type SignedCommit = DagJWS;
export declare type SignedCommitContainer = DagJWSResult;
export declare type CeramicCommit = AnchorCommit | GenesisCommit | RawCommit | SignedCommit | SignedCommitContainer;
export interface StreamMetadata {
    controllers: Array<string>;
    model?: StreamID;
    context?: StreamID;
    family?: string;
    schema?: string;
    tags?: Array<string>;
    forbidControllerChange?: boolean;
    shouldIndex?: boolean;
    [index: string]: any;
}
export interface StreamNext {
    content?: any;
    metadata?: StreamMetadata;
}
export declare enum EventType {
    INIT = 0,
    DATA = 1,
    TIME = 2
}
export interface LogEntry {
    cid: CID;
    type: EventType;
    timestamp?: number;
    expirationTime?: number;
}
export interface CommitData extends LogEntry {
    commit: any;
    envelope?: DagJWS;
    proof?: AnchorProof;
    anchorValidationError?: Error;
    capability?: Cacao;
}
export declare type AppliableStreamLog = {
    commits: Array<CommitData>;
    timestampStatus: 'validated';
};
export declare type UnappliableStreamLog = {
    commits: Array<CommitData>;
    timestampStatus: 'pending';
};
export declare type SyncedStreamLog = AppliableStreamLog | UnappliableStreamLog;
export interface StreamState<TMetadata = StreamMetadata> {
    type: number;
    content: any;
    next?: StreamNext;
    metadata: TMetadata;
    signature: SignatureStatus;
    anchorStatus: AnchorStatus;
    anchorProof?: AnchorProof;
    log: NonEmptyArray<LogEntry>;
}
export interface StreamStateHolder {
    id: StreamID;
    state: StreamState;
}
export declare abstract class Stream extends Observable<StreamState> implements StreamStateHolder {
    protected readonly state$: RunningStateLike;
    private readonly _api;
    constructor(state$: RunningStateLike, api: StreamReaderWriter);
    get id(): StreamID;
    get api(): StreamReaderWriter;
    abstract get metadata(): Record<string, any>;
    get content(): any;
    get tip(): CID;
    get commitId(): CommitID;
    get allCommitIds(): Array<CommitID>;
    get anchorCommitIds(): Array<CommitID>;
    get state(): StreamState;
    sync(opts?: LoadOpts): Promise<void>;
    requestAnchor(): Promise<AnchorStatus>;
    abstract makeReadOnly(): void;
    abstract isReadOnly: boolean;
}
export declare function StreamStatic<T>(): <U extends T>(constructor: U) => any;
export interface StreamConstructor<T extends Stream> {
    new (state$: RunningStateLike, api: StreamReaderWriter): T;
}
export interface StreamHandler<T extends Stream> {
    type: number;
    name: string;
    stream_constructor: StreamConstructor<T>;
    applyCommit(commitData: CommitData, api: StreamReaderWriter, state?: StreamState): Promise<StreamState>;
}
//# sourceMappingURL=stream.d.ts.map