@uns-kit/core 0.0.1

package/dist/graphql/schema.d.ts

@@ -0,0 +1,377 @@
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Date: {
+        input: any;
+        output: any;
+    };
+    Timestamp: {
+        input: any;
+        output: any;
+    };
+};
+export type InitUnsTopic = {
+    topic?: InputMaybe<Scalars['String']['input']>;
+};
+export type InsertUnsNode = {
+    apiDescription?: InputMaybe<Scalars['String']['input']>;
+    apiEndpoint?: InputMaybe<Scalars['String']['input']>;
+    apiMethod?: InputMaybe<Scalars['String']['input']>;
+    attributeNeedsPersistance?: InputMaybe<Scalars['Boolean']['input']>;
+    attributeTags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    attributeTimestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    attributeType?: InputMaybe<UnsAttributeType>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    fullTopic?: InputMaybe<Scalars['String']['input']>;
+    parent: Scalars['Int']['input'];
+    processName?: InputMaybe<Scalars['String']['input']>;
+    processVersion?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<UnsNodeType>;
+    unsNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    AddUnsNode?: Maybe<Scalars['Int']['output']>;
+    DeleteRttNode?: Maybe<Scalars['Boolean']['output']>;
+    DeleteUnsNode?: Maybe<Scalars['Boolean']['output']>;
+    DeployRttNode?: Maybe<Scalars['Boolean']['output']>;
+    ModifyUnsNode?: Maybe<Scalars['Boolean']['output']>;
+    /** Purge all nodes that are older the maxAge in hours */
+    PurgeOldNodes?: Maybe<Scalars['Boolean']['output']>;
+    SetRttNodeConfig?: Maybe<Scalars['Boolean']['output']>;
+    StartRttNode?: Maybe<Scalars['Boolean']['output']>;
+    StopRttNode?: Maybe<Scalars['Boolean']['output']>;
+};
+export type MutationAddUnsNodeArgs = {
+    node?: InputMaybe<InsertUnsNode>;
+};
+export type MutationDeleteRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationDeleteUnsNodeArgs = {
+    id?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MutationDeployRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+    tag?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationModifyUnsNodeArgs = {
+    id?: InputMaybe<Scalars['Int']['input']>;
+    node?: InputMaybe<UpdateUnsNode>;
+};
+export type MutationPurgeOldNodesArgs = {
+    maxAge?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MutationSetRttNodeConfigArgs = {
+    configuration?: InputMaybe<Scalars['String']['input']>;
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationStartRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationStopRttNodeArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+/** name: uns-datahub */
+export type Query = {
+    __typename?: 'Query';
+    GetRepositories?: Maybe<Array<Maybe<Repository>>>;
+    GetRttNodeConfig?: Maybe<Scalars['String']['output']>;
+    GetRttNodes?: Maybe<Array<Maybe<RttNode>>>;
+    GetTags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    GetTreeStructure?: Maybe<Array<Maybe<TreeStructure>>>;
+    GetUnsNodes?: Maybe<Array<Maybe<UnsNode>>>;
+};
+/** name: uns-datahub */
+export type QueryGetRttNodeConfigArgs = {
+    rttNode?: InputMaybe<Scalars['String']['input']>;
+};
+/** name: uns-datahub */
+export type QueryGetTreeStructureArgs = {
+    attributeTags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export type Repository = {
+    __typename?: 'Repository';
+    name?: Maybe<Scalars['String']['output']>;
+    tags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type RttNode = {
+    __typename?: 'RttNode';
+    author?: Maybe<Scalars['String']['output']>;
+    deployedVersions?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    lastErrLog?: Maybe<Scalars['String']['output']>;
+    lastLog?: Maybe<Scalars['String']['output']>;
+    latestDeployedVersion?: Maybe<Scalars['String']['output']>;
+    memory?: Maybe<Scalars['Int']['output']>;
+    pid?: Maybe<Scalars['Int']['output']>;
+    restarts?: Maybe<Scalars['Int']['output']>;
+    rttNode?: Maybe<Scalars['String']['output']>;
+    runningVersion?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+    topics?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    uptime?: Maybe<Scalars['Int']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type TreeStructure = {
+    __typename?: 'TreeStructure';
+    apiDescription?: Maybe<Scalars['String']['output']>;
+    apiEndpoint?: Maybe<Scalars['String']['output']>;
+    apiMethod?: Maybe<Scalars['String']['output']>;
+    attributeNeedsPersistance?: Maybe<Scalars['Boolean']['output']>;
+    attributeTags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    attributeTimestamp?: Maybe<Scalars['Timestamp']['output']>;
+    attributeType?: Maybe<UnsAttributeType>;
+    children?: Maybe<Array<Maybe<TreeStructure>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    fullTopic?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['Int']['output']>;
+    parent?: Maybe<Scalars['Int']['output']>;
+    processName?: Maybe<Scalars['String']['output']>;
+    processVersion?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<UnsNodeType>;
+    unsNode?: Maybe<Scalars['String']['output']>;
+};
+export declare enum UnsAttributeType {
+    Api = "Api",
+    Data = "Data",
+    Event = "Event",
+    Table = "Table"
+}
+export type UnsNode = {
+    __typename?: 'UnsNode';
+    apiDescription?: Maybe<Scalars['String']['output']>;
+    apiEndpoint?: Maybe<Scalars['String']['output']>;
+    apiMethod?: Maybe<Scalars['String']['output']>;
+    attributeNeedsPersistance?: Maybe<Scalars['Boolean']['output']>;
+    attributeTags?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    attributeTimestamp?: Maybe<Scalars['Timestamp']['output']>;
+    attributeType?: Maybe<UnsAttributeType>;
+    description?: Maybe<Scalars['String']['output']>;
+    fullTopic?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['Int']['output']>;
+    parent?: Maybe<Scalars['Int']['output']>;
+    processName?: Maybe<Scalars['String']['output']>;
+    processVersion?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<UnsNodeType>;
+    unsNode?: Maybe<Scalars['String']['output']>;
+};
+export declare enum UnsNodeType {
+    Attribute = "Attribute",
+    DynamicTopic = "DynamicTopic",
+    Topic = "Topic"
+}
+export type UpdateUnsNode = {
+    apiDescription?: InputMaybe<Scalars['String']['input']>;
+    apiEndpoint?: InputMaybe<Scalars['String']['input']>;
+    apiMethod?: InputMaybe<Scalars['String']['input']>;
+    attributeNeedsPersistance?: InputMaybe<Scalars['Boolean']['input']>;
+    attributeTags?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    attributeTimestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    attributeType?: InputMaybe<UnsAttributeType>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    fullTopic?: InputMaybe<Scalars['String']['input']>;
+    parent?: InputMaybe<Scalars['Int']['input']>;
+    processName?: InputMaybe<Scalars['String']['input']>;
+    processVersion?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<UnsNodeType>;
+    unsNode?: InputMaybe<Scalars['String']['input']>;
+};
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+    subscribe: SubscriptionSubscribeFn<{
+        [key in TKey]: TResult;
+    }, TParent, TContext, TArgs>;
+    resolve?: SubscriptionResolveFn<TResult, {
+        [key in TKey]: TResult;
+    }, TContext, TArgs>;
+}
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+    subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+    resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type NextResolverFn<T> = () => Promise<T>;
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+/** Mapping between all available schema types and the resolvers types */
+export type ResolversTypes = {
+    Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+    Date: ResolverTypeWrapper<Scalars['Date']['output']>;
+    InitUnsTopic: InitUnsTopic;
+    InsertUnsNode: InsertUnsNode;
+    Int: ResolverTypeWrapper<Scalars['Int']['output']>;
+    Mutation: ResolverTypeWrapper<{}>;
+    Query: ResolverTypeWrapper<{}>;
+    Repository: ResolverTypeWrapper<Repository>;
+    RttNode: ResolverTypeWrapper<RttNode>;
+    String: ResolverTypeWrapper<Scalars['String']['output']>;
+    Timestamp: ResolverTypeWrapper<Scalars['Timestamp']['output']>;
+    TreeStructure: ResolverTypeWrapper<TreeStructure>;
+    UnsAttributeType: UnsAttributeType;
+    UnsNode: ResolverTypeWrapper<UnsNode>;
+    UnsNodeType: UnsNodeType;
+    UpdateUnsNode: UpdateUnsNode;
+};
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = {
+    Boolean: Scalars['Boolean']['output'];
+    Date: Scalars['Date']['output'];
+    InitUnsTopic: InitUnsTopic;
+    InsertUnsNode: InsertUnsNode;
+    Int: Scalars['Int']['output'];
+    Mutation: {};
+    Query: {};
+    Repository: Repository;
+    RttNode: RttNode;
+    String: Scalars['String']['output'];
+    Timestamp: Scalars['Timestamp']['output'];
+    TreeStructure: TreeStructure;
+    UnsNode: UnsNode;
+    UpdateUnsNode: UpdateUnsNode;
+};
+export interface DateScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Date'], any> {
+    name: 'Date';
+}
+export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
+    AddUnsNode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType, Partial<MutationAddUnsNodeArgs>>;
+    DeleteRttNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationDeleteRttNodeArgs>>;
+    DeleteUnsNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationDeleteUnsNodeArgs>>;
+    DeployRttNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationDeployRttNodeArgs>>;
+    ModifyUnsNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationModifyUnsNodeArgs>>;
+    PurgeOldNodes?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationPurgeOldNodesArgs>>;
+    SetRttNodeConfig?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationSetRttNodeConfigArgs>>;
+    StartRttNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationStartRttNodeArgs>>;
+    StopRttNode?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType, Partial<MutationStopRttNodeArgs>>;
+};
+export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
+    GetRepositories?: Resolver<Maybe<Array<Maybe<ResolversTypes['Repository']>>>, ParentType, ContextType>;
+    GetRttNodeConfig?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType, Partial<QueryGetRttNodeConfigArgs>>;
+    GetRttNodes?: Resolver<Maybe<Array<Maybe<ResolversTypes['RttNode']>>>, ParentType, ContextType>;
+    GetTags?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    GetTreeStructure?: Resolver<Maybe<Array<Maybe<ResolversTypes['TreeStructure']>>>, ParentType, ContextType, Partial<QueryGetTreeStructureArgs>>;
+    GetUnsNodes?: Resolver<Maybe<Array<Maybe<ResolversTypes['UnsNode']>>>, ParentType, ContextType>;
+};
+export type RepositoryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Repository'] = ResolversParentTypes['Repository']> = {
+    name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    tags?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type RttNodeResolvers<ContextType = any, ParentType extends ResolversParentTypes['RttNode'] = ResolversParentTypes['RttNode']> = {
+    author?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    deployedVersions?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    lastErrLog?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    lastLog?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    latestDeployedVersion?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    memory?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    pid?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    restarts?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    rttNode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    runningVersion?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    status?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    topics?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    uptime?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    version?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export interface TimestampScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Timestamp'], any> {
+    name: 'Timestamp';
+}
+export type TreeStructureResolvers<ContextType = any, ParentType extends ResolversParentTypes['TreeStructure'] = ResolversParentTypes['TreeStructure']> = {
+    apiDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    apiEndpoint?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    apiMethod?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    attributeNeedsPersistance?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    attributeTags?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    attributeTimestamp?: Resolver<Maybe<ResolversTypes['Timestamp']>, ParentType, ContextType>;
+    attributeType?: Resolver<Maybe<ResolversTypes['UnsAttributeType']>, ParentType, ContextType>;
+    children?: Resolver<Maybe<Array<Maybe<ResolversTypes['TreeStructure']>>>, ParentType, ContextType>;
+    description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    fullTopic?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    parent?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    processName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    processVersion?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    type?: Resolver<Maybe<ResolversTypes['UnsNodeType']>, ParentType, ContextType>;
+    unsNode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type UnsNodeResolvers<ContextType = any, ParentType extends ResolversParentTypes['UnsNode'] = ResolversParentTypes['UnsNode']> = {
+    apiDescription?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    apiEndpoint?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    apiMethod?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    attributeNeedsPersistance?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+    attributeTags?: Resolver<Maybe<Array<Maybe<ResolversTypes['String']>>>, ParentType, ContextType>;
+    attributeTimestamp?: Resolver<Maybe<ResolversTypes['Timestamp']>, ParentType, ContextType>;
+    attributeType?: Resolver<Maybe<ResolversTypes['UnsAttributeType']>, ParentType, ContextType>;
+    description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    fullTopic?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    parent?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+    processName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    processVersion?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    type?: Resolver<Maybe<ResolversTypes['UnsNodeType']>, ParentType, ContextType>;
+    unsNode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type Resolvers<ContextType = any> = {
+    Date?: GraphQLScalarType;
+    Mutation?: MutationResolvers<ContextType>;
+    Query?: QueryResolvers<ContextType>;
+    Repository?: RepositoryResolvers<ContextType>;
+    RttNode?: RttNodeResolvers<ContextType>;
+    Timestamp?: GraphQLScalarType;
+    TreeStructure?: TreeStructureResolvers<ContextType>;
+    UnsNode?: UnsNodeResolvers<ContextType>;
+};

package/dist/graphql/schema.js

@@ -0,0 +1,13 @@
+export var UnsAttributeType;
+(function (UnsAttributeType) {
+    UnsAttributeType["Api"] = "Api";
+    UnsAttributeType["Data"] = "Data";
+    UnsAttributeType["Event"] = "Event";
+    UnsAttributeType["Table"] = "Table";
+})(UnsAttributeType || (UnsAttributeType = {}));
+export var UnsNodeType;
+(function (UnsNodeType) {
+    UnsNodeType["Attribute"] = "Attribute";
+    UnsNodeType["DynamicTopic"] = "DynamicTopic";
+    UnsNodeType["Topic"] = "Topic";
+})(UnsNodeType || (UnsNodeType = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { default as UnsProxyProcess } from "./uns/uns-proxy-process.js";
+export type { UnsProxyProcessPlugin, UnsProxyProcessPluginApi, UnsProxyProcessPluginMethod, UnsProxyProcessPluginMethods, } from "./uns/uns-proxy-process.js";
+export * from "./uns/uns-interfaces.js";
+export { ConfigFile } from "./config-file.js";
+export { default as logger } from "./logger.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { default as UnsProxyProcess } from "./uns/uns-proxy-process.js";
+export * from "./uns/uns-interfaces.js";
+export { ConfigFile } from "./config-file.js";
+export { default as logger } from "./logger.js";

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("winston").Logger;
+export default logger;

package/dist/logger.js

@@ -0,0 +1,18 @@
+import { createLogger, format, transports } from 'winston';
+const logger = createLogger({
+    level: 'info', // Default logging level
+    format: format.combine(format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), format.errors({ stack: true }), // Include stack trace
+    format.splat(), format.json()),
+    transports: [
+        new transports.Console(), // Log to console only
+        // Remove the file transports to prevent logging to files
+        // new transports.File({ filename: 'logs/error.log', level: 'error' }), 
+        // new transports.File({ filename: 'logs/combined.log' })
+    ],
+    exceptionHandlers: [
+        new transports.Console(), // Log exceptions to console
+        // Remove exception logging to file
+        // new transports.File({ filename: 'logs/exceptions.log' })
+    ]
+});
+export default logger;

package/dist/tools/auth/auth-client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AuthClient handles acquiring and refreshing JWT access tokens
+ * using the configured REST base URL.
+ */
+export declare class AuthClient {
+    private readonly restBase;
+    private readonly namespace;
+    private store;
+    private constructor();
+    static create(): Promise<AuthClient>;
+    getAccessToken(): Promise<string>;
+    private static isExpired;
+    private static endpoint;
+    private static fetchWithTimeout;
+    private static extractRefreshCookie;
+    private login;
+    private refresh;
+    private persistTokens;
+    static promptCredentials(): Promise<{
+        email: string;
+        password: string;
+    }>;
+}

package/dist/tools/auth/auth-client.js

@@ -0,0 +1,172 @@
+import { ConfigFile } from "../../config-file.js";
+import { SecureStoreFactory } from "./secure-store.js";
+import jwt from "jsonwebtoken";
+import readline from "readline";
+/**
+ * AuthClient handles acquiring and refreshing JWT access tokens
+ * using the configured REST base URL.
+ */
+export class AuthClient {
+    restBase;
+    namespace;
+    store;
+    constructor(restBase) {
+        this.restBase = restBase.replace(/\/$/, "");
+        // namespace store by rest base to allow multiple environments
+        this.namespace = `uns-auth:${this.restBase}`;
+    }
+    static async create() {
+        const cfg = await ConfigFile.loadConfig();
+        const restBase = cfg?.uns?.rest;
+        if (!restBase)
+            throw new Error("config.uns.rest is not set");
+        const client = new AuthClient(restBase);
+        client.store = await SecureStoreFactory.create(client.namespace);
+        return client;
+    }
+    async getAccessToken() {
+        const accessToken = await this.store.get("accessToken");
+        const refreshToken = await this.store.get("refreshToken");
+        if (accessToken && !AuthClient.isExpired(accessToken)) {
+            return accessToken;
+        }
+        // Try refresh if we have refresh token
+        if (refreshToken) {
+            try {
+                const refreshed = await this.refresh(refreshToken);
+                await this.persistTokens(refreshed.accessToken, refreshed.refreshToken);
+                return refreshed.accessToken;
+            }
+            catch {
+                // ignore, fallback to login
+            }
+        }
+        // Interactive login
+        const { email, password } = await AuthClient.promptCredentials();
+        const loggedIn = await this.login(email, password);
+        await this.persistTokens(loggedIn.accessToken, loggedIn.refreshToken);
+        return loggedIn.accessToken;
+    }
+    static isExpired(token, skewSeconds = 30) {
+        try {
+            const decoded = jwt.decode(token);
+            if (!decoded || typeof decoded !== "object" || !decoded.exp)
+                return true;
+            const now = Math.floor(Date.now() / 1000);
+            return decoded.exp <= now + skewSeconds;
+        }
+        catch {
+            return true;
+        }
+    }
+    static endpoint(base, tail) {
+        // base ends without trailing slash; tail must not start with slash
+        const b = base.replace(/\/$/, "");
+        const t = tail.replace(/^\//, "");
+        return `${b}/${t}`;
+    }
+    static async fetchWithTimeout(url, init = {}, timeoutMs = 10_000) {
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(url, { ...init, signal: controller.signal });
+            return resp;
+        }
+        finally {
+            clearTimeout(id);
+        }
+    }
+    static extractRefreshCookie(resp) {
+        const anyHeaders = resp.headers;
+        const getSetCookie = typeof anyHeaders.getSetCookie === "function" ? anyHeaders.getSetCookie.bind(anyHeaders) : null;
+        const candidates = getSetCookie ? getSetCookie() : (resp.headers.get("set-cookie") ? [resp.headers.get("set-cookie")] : []);
+        for (const header of candidates) {
+            const match = header.match(/(?:^|;\s*)RefreshToken=([^;]+)/i);
+            if (match)
+                return match[1];
+        }
+        return null;
+    }
+    async login(email, password) {
+        const url = AuthClient.endpoint(this.restBase, "auth/login");
+        const resp = await AuthClient.fetchWithTimeout(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ email, password }),
+        }, 12_000);
+        if (!resp.ok) {
+            throw new Error(`Login failed: ${resp.status} ${resp.statusText}`);
+        }
+        const data = (await resp.json());
+        const refreshToken = AuthClient.extractRefreshCookie(resp);
+        if (!data?.accessToken || !refreshToken) {
+            throw new Error("Login response missing tokens");
+        }
+        return { accessToken: data.accessToken, refreshToken };
+    }
+    async refresh(refreshToken) {
+        const url = AuthClient.endpoint(this.restBase, "auth/refresh");
+        const resp = await AuthClient.fetchWithTimeout(url, {
+            method: "POST",
+            headers: {
+                // server expects cookie RefreshToken
+                "Cookie": `RefreshToken=${refreshToken}`,
+            },
+        }, 8_000);
+        if (!resp.ok) {
+            throw new Error(`Refresh failed: ${resp.status} ${resp.statusText}`);
+        }
+        const data = (await resp.json());
+        const newRefreshToken = AuthClient.extractRefreshCookie(resp) || refreshToken;
+        if (!data?.accessToken)
+            throw new Error("Refresh response missing accessToken");
+        return { accessToken: data.accessToken, refreshToken: newRefreshToken };
+    }
+    async persistTokens(accessToken, refreshToken) {
+        await this.store.set("accessToken", accessToken);
+        await this.store.set("refreshToken", refreshToken);
+    }
+    static async promptCredentials() {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+        const ask = (q) => new Promise((resolve) => rl.question(q, (ans) => resolve(ans.trim())));
+        const askMasked = (q) => new Promise((resolve) => {
+            const anyRl = rl;
+            const out = anyRl.output || process.stdout;
+            const origWrite = anyRl._writeToOutput?.bind(rl) || ((s) => out.write(s));
+            anyRl.stdoutMuted = true;
+            anyRl._writeToOutput = function (stringToWrite) {
+                // Keep prompt text intact; mask user input
+                if (anyRl.stdoutMuted) {
+                    if (stringToWrite.startsWith(q)) {
+                        out.write(stringToWrite);
+                    }
+                    else if (stringToWrite.endsWith("\n")) {
+                        out.write("\n");
+                    }
+                    else {
+                        out.write("*");
+                    }
+                }
+                else {
+                    origWrite(stringToWrite);
+                }
+            };
+            rl.question(q, (value) => {
+                anyRl.stdoutMuted = false;
+                anyRl._writeToOutput = origWrite;
+                out.write("\n");
+                resolve(value.trim());
+            });
+        });
+        try {
+            const email = await ask("Email: ");
+            const password = await askMasked("Password: ");
+            rl.close();
+            return { email, password };
+        }
+        catch (e) {
+            rl.close();
+            throw e;
+        }
+    }
+}

package/dist/tools/auth/index.d.ts

@@ -0,0 +1 @@
+export { AuthClient } from "./auth-client.js";

package/dist/tools/auth/index.js

@@ -0,0 +1 @@
+export { AuthClient } from "./auth-client.js";

package/dist/tools/auth/secure-store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Abstraction over secure storage for tokens.
+ *
+ * Prefers OS keychain via `keytar` if available at runtime.
+ * Falls back to a local file store with restricted permissions.
+ */
+export interface ISecureStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    del(key: string): Promise<void>;
+}
+export declare class SecureStoreFactory {
+    /**
+     * Creates a secure store for a namespace. Tries keytar first; falls back to file store.
+     */
+    static create(namespace: string): Promise<ISecureStore>;
+}