@actyx/sdk/lib/internal_common/types.d.ts

Actyx SDK

import { Ord } from 'fp-ts/lib/Ord';
import { Ordering } from 'fp-ts/lib/Ordering';
import * as t from 'io-ts';
import { EventsSortOrder, NodeStatus } from '../types';
export declare class EnumType<A> extends t.Type<A> {
    readonly _tag: 'EnumType';
    enumObject: object;
    constructor(e: object, name?: string);
}
export declare const createEnumType: <T>(e: object, name?: string | undefined) => EnumType<T>;
export declare const OffsetsResponse: t.ReadonlyC<t.TypeC<{
    present: t.ReadonlyC<t.ReadonlyC<t.RecordC<t.StringC, t.Type<number, number, unknown>>>>;
    toReplicate: t.RecordC<t.Type<string, string, unknown>, t.NumberC>;
}>>;
export declare type OffsetsResponse = t.TypeOf<typeof OffsetsResponse>;
declare type Tags = string[];
declare type TagsOnWire = string[] | undefined;
declare const Tags: t.Type<Tags, TagsOnWire, unknown>;
export declare const EventIO: t.TypeC<{
    offset: t.Type<number, number, unknown>;
    stream: t.Type<string, string, unknown>;
    timestamp: t.Type<number, number, unknown>;
    lamport: t.Type<number, number, unknown>;
    appId: t.Type<string, string, unknown>;
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>;
export declare type Event = t.TypeOf<typeof EventIO>;
export declare const _compareEvents: (a: Event, b: Event) => Ordering;
export declare const MonotonicEventIO: t.IntersectionC<[t.TypeC<{
    offset: t.Type<number, number, unknown>;
    stream: t.Type<string, string, unknown>;
    timestamp: t.Type<number, number, unknown>;
    lamport: t.Type<number, number, unknown>;
    appId: t.Type<string, string, unknown>;
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>, t.TypeC<{
    type: t.LiteralC<"event">;
    caughtUp: t.BooleanC;
}>]>;
export declare const DiagnosticIO: t.TypeC<{
    type: t.LiteralC<"diagnostic">;
    severity: t.KeyofC<{
        warning: number;
        error: number;
    }>;
    message: t.StringC;
}>;
export declare const OffsetsIO: t.TypeC<{
    type: t.LiteralC<"offsets">;
    offsets: t.ReadonlyC<t.RecordC<t.StringC, t.Type<number, number, unknown>>>;
}>;
export declare const TimeTravelIO: t.TypeC<{
    type: t.LiteralC<"timeTravel">;
    newStart: t.ReadonlyC<t.TypeC<{
        lamport: t.Type<number, number, unknown>;
        offset: t.Type<number, number, unknown>;
        stream: t.Type<string, string, unknown>;
    }>>;
}>;
export declare const SubscribeMonotonicResponseIO: t.UnionC<[t.IntersectionC<[t.TypeC<{
    offset: t.Type<number, number, unknown>;
    stream: t.Type<string, string, unknown>;
    timestamp: t.Type<number, number, unknown>;
    lamport: t.Type<number, number, unknown>;
    appId: t.Type<string, string, unknown>;
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>, t.TypeC<{
    type: t.LiteralC<"event">;
    caughtUp: t.BooleanC;
}>]>, t.TypeC<{
    type: t.LiteralC<"diagnostic">;
    severity: t.KeyofC<{
        warning: number;
        error: number;
    }>;
    message: t.StringC;
}>, t.TypeC<{
    type: t.LiteralC<"offsets">;
    offsets: t.ReadonlyC<t.RecordC<t.StringC, t.Type<number, number, unknown>>>;
}>, t.TypeC<{
    type: t.LiteralC<"timeTravel">;
    newStart: t.ReadonlyC<t.TypeC<{
        lamport: t.Type<number, number, unknown>;
        offset: t.Type<number, number, unknown>;
        stream: t.Type<string, string, unknown>;
    }>>;
}>]>;
export declare type SubscribeMonotonicResponseIO = t.TypeOf<typeof SubscribeMonotonicResponseIO>;
export declare const Event: {
    ord: Ord<{
        offset: number;
        stream: string;
        timestamp: number;
        lamport: number;
        appId: string;
        tags: Tags;
        payload: unknown;
    }>;
};
/**
 * A number of events, not necessarily from the same source
 */
export declare const Events: t.ArrayC<t.TypeC<{
    offset: t.Type<number, number, unknown>;
    stream: t.Type<string, string, unknown>;
    timestamp: t.Type<number, number, unknown>;
    lamport: t.Type<number, number, unknown>;
    appId: t.Type<string, string, unknown>;
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>>;
export declare type Events = t.TypeOf<typeof Events>;
/**
 * A number of generated events, that are going to be written to the store.
 */
export declare const UnstoredEvent: t.ReadonlyC<t.TypeC<{
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>>;
export declare type UnstoredEvent = t.TypeOf<typeof UnstoredEvent>;
export declare const UnstoredEvents: t.ReadonlyArrayC<t.ReadonlyC<t.TypeC<{
    tags: t.Type<Tags, TagsOnWire, unknown>;
    payload: t.UnknownC;
}>>>;
export declare type UnstoredEvents = t.TypeOf<typeof UnstoredEvents>;
export declare const EventsSortOrders: EnumType<EventsSortOrder>;
export declare type EventsSortOrders = t.TypeOf<typeof EventsSortOrders>;
/**
 * Connectivity status type.
 */
export declare enum ConnectivityStatusType {
    FullyConnected = "FullyConnected",
    PartiallyConnected = "PartiallyConnected",
    NotConnected = "NotConnected"
}
/**
 * The IO-TS type parser for ConnectivityStatus.
 * @public
 */
export declare const ConnectivityStatus: t.UnionC<[t.ReadonlyC<t.TypeC<{
    status: t.LiteralC<ConnectivityStatusType.FullyConnected>;
    inCurrentStatusForMs: t.NumberC;
}>>, t.ReadonlyC<t.TypeC<{
    status: t.LiteralC<ConnectivityStatusType.PartiallyConnected>;
    inCurrentStatusForMs: t.NumberC;
    specialsDisconnected: t.ReadonlyArrayC<t.StringC>;
    swarmConnectivityLevel: t.NumberC;
    eventsToRead: t.NumberC;
    eventsToSend: t.NumberC;
}>>, t.ReadonlyC<t.TypeC<{
    status: t.LiteralC<ConnectivityStatusType.NotConnected>;
    inCurrentStatusForMs: t.NumberC;
    eventsToRead: t.NumberC;
    eventsToSend: t.NumberC;
}>>]>;
/**
 * Current connectivity of the underlying Actyx node.
 * @public
 */
export declare type ConnectivityStatus = t.TypeOf<typeof ConnectivityStatus>;
/** Hook to run on store connection being closed. */
export declare type StoreConnectionClosedHook = () => void;
/** Configuration for the WebSocket store connection. */
export declare type WsStoreConfig = {
    /** url of the destination */
    url: string;
    /** protocol of the destination */
    protocol?: string;
    /** Hook, when the connection to the store is closed */
    onStoreConnectionClosed?: StoreConnectionClosedHook;
    /** retry interval to establish the connection */
    reconnectTimeout?: number;
};
export declare const NodeStatusIo: EnumType<NodeStatus>;
export declare const SwarmState: t.TypeC<{
    peersStatus: t.RecordC<t.Type<string, string, unknown>, EnumType<NodeStatus>>;
}>;
export declare const NodeInfo: t.TypeC<{
    connectedNodes: t.NumberC;
    uptime: t.TypeC<{
        secs: t.NumberC;
        nanos: t.NumberC;
    }>;
    version: t.StringC;
    swarmState: t.UnionC<[t.UndefinedC, t.TypeC<{
        peersStatus: t.RecordC<t.Type<string, string, unknown>, EnumType<NodeStatus>>;
    }>]>;
}>;
export declare type NodeInfo = t.TypeOf<typeof NodeInfo>;
export {};