camstreamerlib 4.0.0-beta.1 → 4.0.0-beta.3

package/esm/node/DefaultClient.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IClient, HttpOptions, TParameters } from '../internal/common';
+export declare class DefaultClient implements IClient {
+    private tls;
+    private ip;
+    private port;
+    private user;
+    private pass;
+    private httpRequestSender;
+    constructor(opt?: HttpOptions);
+    get url(): string;
+    get(path: string, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    post(path: string, data: string | FormData | Buffer, parameters?: TParameters, headers?: Record<string, string>): Promise<import("undici").Response>;
+    private getBaseConnectionParams;
+}

package/esm/node/HttpRequestSender.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { FormData as UndiciFormData, Response as UndiciResponse } from 'undici';
+export type HttpRequestOptions = {
+    method?: string;
+    protocol: string;
+    host: string;
+    port: number;
+    path: string;
+    user?: string;
+    pass?: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+};
+export type AgentOptions = {
+    rejectUnaurhorized?: boolean;
+    keepAlive?: boolean;
+};
+export declare class HttpRequestSender {
+    private agent?;
+    private authData?;
+    constructor(agentOptions?: AgentOptions);
+    sendRequest(options: HttpRequestOptions, postData?: Buffer | string | UndiciFormData): Promise<UndiciResponse>;
+    private sendRequestWithAuth;
+    private static getURL;
+    private getAuthorization;
+    private invalidateAuthorization;
+    private static getAuthHeader;
+}

package/esm/node/HttpServer.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as EventEmitter from 'events';
+export type HttpServerOptions = {
+    host?: string;
+    port?: number;
+};
+type TOnRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare class HttpServer extends EventEmitter {
+    private host;
+    private port;
+    private registeredPaths;
+    private server;
+    private sockets;
+    constructor(options?: HttpServerOptions);
+    getServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    onRequest(pathName: string, callback: TOnRequestCallback): void;
+    close(): void;
+}
+export {};

package/esm/node/WsClient.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as EventEmitter from 'events';
+import { WsOptions } from '../internal/common';
+export type WsClientOptions = WsOptions & {
+    address: string;
+    headers?: Record<string, string>;
+    pingInterval?: number;
+    protocol?: string;
+};
+export interface WsClient {
+    on(event: 'open', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'message', listener: (data: Buffer) => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    emit(event: 'open'): boolean;
+    emit(event: 'close'): boolean;
+    emit(event: 'message', data: Buffer): boolean;
+    emit(event: 'error', err: Error): boolean;
+}
+export declare class WsClient extends EventEmitter {
+    private user;
+    private pass;
+    private address;
+    private protocol?;
+    private pingInterval;
+    private wsOptions;
+    private digestAddress;
+    private isAlive;
+    private pingTimer?;
+    private ws?;
+    private isClosed;
+    constructor(options: WsClientOptions);
+    open(wwwAuthenticateHeader?: string): void;
+    send(data: Buffer | string): void;
+    close(): void;
+    reconnect(): void;
+    private closeWsConnection;
+}

package/esm/node/WsEventClient.d.ts

@@ -0,0 +1,13 @@
+import { IWebsocket } from '../internal/common';
+import { WsClientOptions } from './WsClient';
+type TEvent = {
+    data: string;
+};
+export declare class WsEventClient implements IWebsocket<TEvent> {
+    private wsClient;
+    constructor(options: WsClientOptions);
+    send: (data: string) => void;
+    destroy: () => void;
+    onmessage: ((event: TEvent) => void) | null;
+}
+export {};

package/esm/node/index.d.ts

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/esm/node/index.js

@@ -0,0 +1,2 @@
+export { DefaultClient } from './DefaultClient';
+export { WsClient } from './WsClient';

package/esm/types/CamOverlayAPI.d.ts

@@ -0,0 +1,188 @@
+import { HttpOptions } from '../internal/common';
+import { z } from 'zod';
+export type CamOverlayOptions = HttpOptions;
+export type TFileType = 'image' | 'font';
+export type TCoordinates = 'top_left' | 'top_right' | 'top' | 'bottom_left' | 'bottom_right' | 'bottom' | 'left' | 'right' | 'center' | '';
+export declare const serviceSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export type TService = z.infer<typeof serviceSchema>;
+export type TServiceList = {
+    services: TService[];
+};
+export declare const fieldSchema: z.ZodObject<{
+    field_name: z.ZodString;
+    text: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    field_name: string;
+    text: string;
+    color?: string | undefined;
+}, {
+    field_name: string;
+    text: string;
+    color?: string | undefined;
+}>;
+export type TField = z.infer<typeof fieldSchema>;
+export declare const fileSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    storage: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    storage: string;
+}, {
+    path: string;
+    name: string;
+    storage: string;
+}>;
+export type TFile = z.infer<typeof fileSchema>;
+export declare const fileListSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    storage: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    storage: string;
+}, {
+    path: string;
+    name: string;
+    storage: string;
+}>, "many">;
+export type TFileList = z.infer<typeof fileListSchema>;
+export declare enum ImageType {
+    PNG = 0,
+    JPEG = 1
+}
+export declare const fontStorageSchema: z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"SD0">;
+    state: z.ZodLiteral<"SD Card">;
+}, "strip", z.ZodTypeAny, {
+    type: "SD0";
+    state: "SD Card";
+}, {
+    type: "SD0";
+    state: "SD Card";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"flash">;
+    state: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "flash";
+    state: string;
+}, {
+    type: "flash";
+    state: string;
+}>], null>;
+export type TFontStorage = z.infer<typeof fontStorageSchema>;
+export declare const imageStorageSchema: z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"SD0">;
+    state: z.ZodLiteral<"SD Card">;
+}, "strip", z.ZodTypeAny, {
+    type: "SD0";
+    state: "SD Card";
+}, {
+    type: "SD0";
+    state: "SD Card";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"flash">;
+    state: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "flash";
+    state: string;
+}, {
+    type: "flash";
+    state: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"samba">;
+    state: z.ZodLiteral<"Microsoft Network Share">;
+}, "strip", z.ZodTypeAny, {
+    type: "samba";
+    state: "Microsoft Network Share";
+}, {
+    type: "samba";
+    state: "Microsoft Network Share";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    state: z.ZodLiteral<"URL">;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    state: "URL";
+}, {
+    type: "url";
+    state: "URL";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ftp">;
+    state: z.ZodLiteral<"FTP">;
+}, "strip", z.ZodTypeAny, {
+    type: "ftp";
+    state: "FTP";
+}, {
+    type: "ftp";
+    state: "FTP";
+}>], null>;
+export type TImageStorage = z.infer<typeof imageStorageSchema>;
+export declare const storageSchema: z.ZodUnion<[z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"SD0">;
+    state: z.ZodLiteral<"SD Card">;
+}, "strip", z.ZodTypeAny, {
+    type: "SD0";
+    state: "SD Card";
+}, {
+    type: "SD0";
+    state: "SD Card";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"flash">;
+    state: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "flash";
+    state: string;
+}, {
+    type: "flash";
+    state: string;
+}>], null>, z.ZodTuple<[z.ZodObject<{
+    type: z.ZodLiteral<"SD0">;
+    state: z.ZodLiteral<"SD Card">;
+}, "strip", z.ZodTypeAny, {
+    type: "SD0";
+    state: "SD Card";
+}, {
+    type: "SD0";
+    state: "SD Card";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"flash">;
+    state: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "flash";
+    state: string;
+}, {
+    type: "flash";
+    state: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"samba">;
+    state: z.ZodLiteral<"Microsoft Network Share">;
+}, "strip", z.ZodTypeAny, {
+    type: "samba";
+    state: "Microsoft Network Share";
+}, {
+    type: "samba";
+    state: "Microsoft Network Share";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    state: z.ZodLiteral<"URL">;
+}, "strip", z.ZodTypeAny, {
+    type: "url";
+    state: "URL";
+}, {
+    type: "url";
+    state: "URL";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ftp">;
+    state: z.ZodLiteral<"FTP">;
+}, "strip", z.ZodTypeAny, {
+    type: "ftp";
+    state: "FTP";
+}, {
+    type: "ftp";
+    state: "FTP";
+}>], null>]>;
+export type TStorage = z.infer<typeof storageSchema>;

package/esm/types/CamScripterAPI.d.ts

@@ -0,0 +1,67 @@
+import { HttpOptions } from '../internal/common';
+import { z } from 'zod';
+export type CamScripterOptions = HttpOptions;
+export type TStorageType = 'INTERNAL' | 'SD_CARD';
+export type TNodeState = 'OK' | 'NOT_INSTALLED' | 'NOT_FOUND';
+export declare const packageInfoListSchema: z.ZodArray<z.ZodObject<{
+    storage: z.ZodUnion<[z.ZodLiteral<"SD_CARD">, z.ZodLiteral<"INTERNAL">]>;
+    manifest: z.ZodObject<{
+        package_name: z.ZodString;
+        package_menu_name: z.ZodString;
+        package_version: z.ZodString;
+        vendor: z.ZodString;
+        required_camscripter_version: z.ZodString;
+        required_camscripter_rbi_version: z.ZodString;
+        ui_link: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    }, {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    storage: "INTERNAL" | "SD_CARD";
+    manifest: {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    };
+}, {
+    storage: "INTERNAL" | "SD_CARD";
+    manifest: {
+        package_name: string;
+        package_menu_name: string;
+        package_version: string;
+        vendor: string;
+        required_camscripter_version: string;
+        required_camscripter_rbi_version: string;
+        ui_link: string;
+    };
+}>, "many">;
+export type TPackageInfoList = z.infer<typeof packageInfoListSchema>;
+export declare const storageSchema: z.ZodArray<z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"INTERNAL">, z.ZodLiteral<"SD_CARD">]>;
+    capacity_mb: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "INTERNAL" | "SD_CARD";
+    capacity_mb: number;
+}, {
+    type: "INTERNAL" | "SD_CARD";
+    capacity_mb: number;
+}>, "many">;
+export type TStorage = z.infer<typeof storageSchema>;

package/esm/types/CamStreamerAPI.d.ts

@@ -0,0 +1,139 @@
+import { HttpOptions } from '../internal/common';
+import { z } from 'zod';
+export type CamStreamerAPIOptions = HttpOptions;
+export declare const streamAttributesSchema: z.ZodObject<{
+    enabled: z.ZodString;
+    active: z.ZodString;
+    audioSource: z.ZodString;
+    avSyncMsec: z.ZodString;
+    internalVapixParameters: z.ZodString;
+    userVapixParameters: z.ZodString;
+    outputParameters: z.ZodString;
+    outputType: z.ZodString;
+    mediaServerUrl: z.ZodString;
+    inputType: z.ZodString;
+    inputUrl: z.ZodString;
+    forceStereo: z.ZodString;
+    streamDelay: z.ZodString;
+    statusLed: z.ZodString;
+    statusPort: z.ZodString;
+    callApi: z.ZodString;
+    trigger: z.ZodString;
+    schedule: z.ZodString;
+    prepareAhead: z.ZodString;
+    startTime: z.ZodString;
+    stopTime: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}>;
+export type TStreamAttributes = z.infer<typeof streamAttributesSchema>;
+export declare const streamListSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    enabled: z.ZodString;
+    active: z.ZodString;
+    audioSource: z.ZodString;
+    avSyncMsec: z.ZodString;
+    internalVapixParameters: z.ZodString;
+    userVapixParameters: z.ZodString;
+    outputParameters: z.ZodString;
+    outputType: z.ZodString;
+    mediaServerUrl: z.ZodString;
+    inputType: z.ZodString;
+    inputUrl: z.ZodString;
+    forceStereo: z.ZodString;
+    streamDelay: z.ZodString;
+    statusLed: z.ZodString;
+    statusPort: z.ZodString;
+    callApi: z.ZodString;
+    trigger: z.ZodString;
+    schedule: z.ZodString;
+    prepareAhead: z.ZodString;
+    startTime: z.ZodString;
+    stopTime: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}, {
+    enabled: string;
+    active: string;
+    audioSource: string;
+    avSyncMsec: string;
+    internalVapixParameters: string;
+    userVapixParameters: string;
+    outputParameters: string;
+    outputType: string;
+    mediaServerUrl: string;
+    inputType: string;
+    inputUrl: string;
+    forceStereo: string;
+    streamDelay: string;
+    statusLed: string;
+    statusPort: string;
+    callApi: string;
+    trigger: string;
+    schedule: string;
+    prepareAhead: string;
+    startTime: string;
+    stopTime: string;
+}>>;
+export type TStreamList = z.infer<typeof streamListSchema>;