ironflock 1.0.2 → 1.2.1

package/dist/index.d.ts

@@ -1,2 +1,169 @@
-import { IronFlock } from "./ironflock";
-export = IronFlock;
+import { default as default_2 } from 'autobahn';
+import { default as default_3 } from 'typia';
+import { EventEmitter } from 'eventemitter3';
+import { IRegistration } from 'autobahn';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Subscription } from 'autobahn';
+import { tags } from 'typia';
+
+export declare type AuthPayload = {
+    success: boolean;
+    role: string;
+    realm: string;
+    authid: string;
+    extra: {
+        username: string;
+    };
+};
+
+export declare interface CallParams {
+    deviceKey: string & tags.MinLength<1>;
+    topic: string & tags.MinLength<1>;
+    args?: unknown[];
+    kwargs?: Record<string, unknown>;
+}
+
+export declare class CrossbarConnection extends EventEmitter {
+    session?: default_2.Session;
+    connection?: default_2.Connection;
+    serial_number?: string;
+    socketURI?: string;
+    realm?: string;
+    private subscriptions;
+    private registrations;
+    private firstConnection?;
+    private firstResolver;
+    private firstRejecter;
+    constructor();
+    static getWebSocketURI(reswarmUrl?: string): string;
+    configure(swarmKey: number, appKey: number, stage: Stage, serialNumber: string, cburl?: string): void;
+    start(): Promise<void>;
+    private onOpen;
+    private onClose;
+    private sessionWait;
+    waitForConnection(): Promise<void | undefined>;
+    getSession(): default_2.Session | undefined;
+    get is_open(): boolean;
+    isConnected(): boolean;
+    stop(): void;
+    subscribe(topic: string, handler: default_2.SubscribeHandler): Promise<default_2.Subscription | undefined>;
+    unsubscribe(sub: default_2.Subscription): Promise<void>;
+    unsubscribeTopic(topic: string): Promise<void>;
+    private resubscribeAll;
+    register(topic: string, endpoint: default_2.RegisterEndpoint): Promise<default_2.IRegistration | undefined>;
+    unregister(registration: default_2.Registration): Promise<void>;
+    call<T>(procedure: string, args?: any[], kwargs?: object, options?: any): Promise<T | undefined>;
+    publish(topic: string, args?: any[], kwargs?: object, options?: any): Promise<default_2.IPublication | undefined>;
+}
+
+export declare type Details = {
+    caller_authid: string;
+    caller_authrole: string;
+};
+
+export declare class IronFlock {
+    private _connection;
+    private _serialNumber;
+    private _deviceName?;
+    private _deviceKey?;
+    private _appName?;
+    private _swarmKey;
+    private _appKey;
+    private _env?;
+    private _isConfigured;
+    private _reswarmUrl?;
+    private _cburl?;
+    constructor(options?: IronFlockOptions);
+    get connection(): CrossbarConnection;
+    get isConnected(): boolean;
+    private configureConnection;
+    start(cburl?: string): Promise<void>;
+    stop(): Promise<void>;
+    publish(topic: string, args?: unknown[], kwargs?: Record<string, unknown>): Promise<unknown>;
+    publishToTable(tablename: string, args?: unknown[], kwargs?: Record<string, unknown>): Promise<unknown>;
+    subscribe(topic: string, handler: (...args: any[]) => void, options?: object): Promise<Subscription<any[], any, string> | undefined>;
+    subscribeToTable(tablename: string, handler: (...args: any[]) => void, options?: object): Promise<Subscription<any[], any, string> | undefined>;
+    call(deviceKey: string, topic: string, args?: unknown[], kwargs?: Record<string, unknown>, options?: object): Promise<unknown>;
+    registerFunction(topic: string, endpoint: (...args: any[]) => any, options?: object): Promise<IRegistration<any, any[], any, string> | undefined>;
+    register(topic: string, endpoint: (...args: any[]) => any, options?: object): Promise<IRegistration<any, any[], any, string> | undefined>;
+    getHistory(tablename: string, queryParams?: TableQueryParams): Promise<unknown>;
+    setDeviceLocation(long: number, lat: number): Promise<unknown>;
+    getRemoteAccessUrlForPort(port: number): string | null;
+    /**
+     * Create an IronFlock instance by fetching configuration from a server endpoint.
+     * The endpoint should return JSON matching `IronFlockOptions`.
+     *
+     * Useful in browser environments where config is provided by a backend:
+     * ```ts
+     * const flock = await IronFlock.fromServer("/api/ironflock-config");
+     * await flock.start();
+     * ```
+     */
+    static fromServer(url: string): Promise<IronFlock>;
+}
+
+export declare interface IronFlockOptions {
+    serialNumber?: string;
+    deviceName?: string;
+    deviceKey?: string;
+    appName?: string;
+    swarmKey?: number;
+    appKey?: number;
+    env?: string;
+    /** URL of the IronFlock studio instance (e.g. "https://studio.ironflock.com") used to resolve the WebSocket URI. */
+    reswarmUrl?: string;
+    /** Direct WebSocket URI override (e.g. "wss://cbw.ironflock.com/ws-ua-usr"). Takes precedence over reswarmUrl. */
+    cburl?: string;
+}
+
+export declare interface ISOTimeRange {
+    start: string & tags.Format<"date-time">;
+    end: string & tags.Format<"date-time">;
+}
+
+export declare interface LocationParams {
+    longitude: number & tags.Minimum<-180> & tags.Maximum<180>;
+    latitude: number & tags.Minimum<-90> & tags.Maximum<90>;
+}
+
+export declare interface PublishParams {
+    topic: string & tags.MinLength<1>;
+    args?: unknown[];
+    kwargs?: Record<string, unknown>;
+}
+
+export declare interface SQLFilterAnd {
+    column: string & tags.MinLength<1>;
+    operator: string & tags.MinLength<1>;
+    value: string | number | boolean | Array<string | number>;
+}
+
+export declare enum Stage {
+    DEVELOPMENT = "dev",
+    PRODUCTION = "prod"
+}
+
+export declare interface TableParams {
+    tablename: string & tags.MinLength<1>;
+    args?: unknown[];
+    kwargs?: Record<string, unknown>;
+}
+
+export declare interface TableQueryParams {
+    limit: number & tags.Type<"uint32"> & tags.Minimum<1> & tags.Maximum<10000>;
+    offset?: number & tags.Type<"uint32"> & tags.Minimum<0>;
+    timeRange?: ISOTimeRange;
+    filterAnd?: SQLFilterAnd[];
+}
+
+export declare const validateCallParams: ((input: unknown) => default_3.IValidation<CallParams>) & StandardSchemaV1<CallParams, CallParams>;
+
+export declare const validateLocationParams: ((input: unknown) => default_3.IValidation<LocationParams>) & StandardSchemaV1<LocationParams, LocationParams>;
+
+export declare const validatePublishParams: ((input: unknown) => default_3.IValidation<PublishParams>) & StandardSchemaV1<PublishParams, PublishParams>;
+
+export declare const validateTableParams: ((input: unknown) => default_3.IValidation<TableParams>) & StandardSchemaV1<TableParams, TableParams>;
+
+export declare const validateTableQueryParams: ((input: unknown) => default_3.IValidation<TableQueryParams>) & StandardSchemaV1<TableQueryParams, TableQueryParams>;
+
+export { }