client_plugin_logic_deb 1.4.91 → 1.4.93

package/Logic_Debertz-client_plugin.d.ts

@@ -194,6 +194,16 @@ export declare namespace com.logic.redux.actions.validation {
         };
     }
 }
+export declare namespace com.logic.utils.logger.game {
+    interface GameLogger extends com.logic.utils.logger.outputs.LoggerOutput {
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.utils.logger.game.GameLogger": unique symbol;
+        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
+    }
+}
 export declare namespace com.logic.utils.logger.game {
     interface LoggerPayload {
         readonly __doNotUseOrImplementIt: {
@@ -201,6 +211,80 @@ export declare namespace com.logic.utils.logger.game {
         };
     }
 }
+export declare namespace com.logic.utils.logger.outputs {
+    abstract class LogType {
+        private constructor();
+        static get DEBUG(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "DEBUG";
+            get ordinal(): 0;
+        };
+        static get ERROR(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "ERROR";
+            get ordinal(): 1;
+        };
+        static get WARN(): com.logic.utils.logger.outputs.LogType & {
+            get name(): "WARN";
+            get ordinal(): 2;
+        };
+        static values(): Array<com.logic.utils.logger.outputs.LogType>;
+        static valueOf(value: string): com.logic.utils.logger.outputs.LogType;
+        get name(): "DEBUG" | "ERROR" | "WARN";
+        get ordinal(): 0 | 1 | 2;
+        static get Companion(): {
+            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.utils.logger.outputs.LogType> */;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
+    }
+}
+export declare namespace com.logic.utils.logger.outputs {
+    interface LoggerEnabledTrigger extends com.logic.utils.logger.game.GameLogger {
+        enabled: boolean;
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.utils.logger.outputs.LoggerEnabledTrigger": unique symbol;
+        } & com.logic.utils.logger.game.GameLogger["__doNotUseOrImplementIt"];
+    }
+}
+export declare namespace com.logic.utils.logger.outputs {
+    interface LoggerOutput {
+        d(tag?: Nullable<string>, message: string, payload?: Nullable<any>): void;
+        e(tag?: Nullable<string>, message?: Nullable<string>, exception?: Nullable<Error>, payload?: Nullable<any>): void;
+        w(tag?: Nullable<string>, message: string, payload?: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.utils.logger.outputs.LoggerOutput": unique symbol;
+        };
+    }
+}
+export declare namespace com.logic.utils.logger.outputs {
+    interface ObservableLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput, com.logic.utils.logger.outputs.LoggerEnabledTrigger {
+        observe(types?: Array<com.logic.utils.logger.outputs.LogType>): any/* kotlinx.coroutines.flow.Flow<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        enabled: boolean;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.logic.utils.logger.outputs.ObservableLoggerOutput": unique symbol;
+        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"] & com.logic.utils.logger.outputs.LoggerEnabledTrigger["__doNotUseOrImplementIt"];
+    }
+    class LoggerOutputDataDto {
+        constructor(type: com.logic.utils.logger.outputs.LogType, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>);
+        get type(): com.logic.utils.logger.outputs.LogType;
+        get tag(): Nullable<string>;
+        get message(): Nullable<string>;
+        get stackTrace(): Nullable<string>;
+        copy(type?: com.logic.utils.logger.outputs.LogType, tag?: Nullable<string>, message?: Nullable<string>, stackTrace?: Nullable<string>): com.logic.utils.logger.outputs.LoggerOutputDataDto;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+        static LoggerOutputDataDto_init_$Create$(seen1: number, type: Nullable<com.logic.utils.logger.outputs.LogType>, tag: Nullable<string>, message: Nullable<string>, stackTrace: Nullable<string>, serializationConstructorMarker: Nullable<any>/* Nullable<kotlinx.serialization.internal.SerializationConstructorMarker> */): com.logic.utils.logger.outputs.LoggerOutputDataDto;
+        static get Companion(): {
+            serializer(): any/* kotlinx.serialization.KSerializer<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
+        };
+        static get $serializer(): {
+        } & any/* kotlinx.serialization.internal.GeneratedSerializer<com.logic.utils.logger.outputs.LoggerOutputDataDto> */;
+    }
+}
 export declare namespace com.debertz.logic {
     interface GameStoreContract {
         readonly id: string;
@@ -772,6 +856,18 @@ export declare namespace com.debertz.logic.client.redux.state {
         equals(other: Nullable<any>): boolean;
     }
 }
+export declare namespace com.debertz.logic.client.utils {
+    interface ShowClientErrorLoggerOutput extends com.logic.utils.logger.outputs.LoggerOutput {
+        skipWarnings: boolean;
+        gameClientProvider: Nullable<() => any/* com.debertz.logic.client.GameClient */>;
+        d(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        e(tag: Nullable<string>, message: Nullable<string>, exception: Nullable<Error>, payload: Nullable<any>): void;
+        w(tag: Nullable<string>, message: string, payload: Nullable<any>): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "com.debertz.logic.client.utils.ShowClientErrorLoggerOutput": unique symbol;
+        } & com.logic.utils.logger.outputs.LoggerOutput["__doNotUseOrImplementIt"];
+    }
+}
 export declare interface GameClientEngineController {
     readonly parser: ParserHelper;
     setEnableLogger(enabled: boolean): void;
@@ -852,21 +948,16 @@ export declare interface TestHelper {
         readonly TestHelper: unique symbol;
     };
 }
-export declare namespace com.logic.plugin.handlers {
-    interface EngineHandler {
-        attach(): void;
-        detach(): void;
-        onMethodCall(controller: com.logic.plugin.utils.events.MethodController): void;
-        onListen(eventSink: com.logic.plugin.utils.events.EventController): void;
-        onCancel(): void;
+export declare namespace com.logic.plugin.utils.events {
+    interface EventSubscriptionCallback {
+        onListen(sink: com.logic.plugin.utils.events.EventController, argument?: Nullable<any>): void;
+        onCancel(argument?: Nullable<any>): void;
         readonly __doNotUseOrImplementIt: {
-            readonly "com.logic.plugin.handlers.EngineHandler": unique symbol;
+            readonly "com.logic.plugin.utils.events.EventSubscriptionCallback": unique symbol;
         };
     }
-}
-export declare namespace com.logic.plugin.utils.events {
     interface EventController {
-        error(error: com.logic.plugin.utils.events.PluginError): void;
+        error(error: Error): void;
         success(data: Nullable<any>): void;
         endOfStream(): void;
         readonly __doNotUseOrImplementIt: {
@@ -878,7 +969,7 @@ export declare namespace com.logic.plugin.utils.events {
     interface MethodController {
         getMethodName(): string;
         getArguments(): Nullable<any>;
-        error(error: com.logic.plugin.utils.events.PluginError): void;
+        error(error: Error): void;
         success(eventData?: Nullable<any>): void;
         notImplemented(): void;
         readonly __doNotUseOrImplementIt: {
@@ -898,4 +989,14 @@ export declare namespace com.logic.plugin.utils.events {
         equals(other: Nullable<any>): boolean;
     }
 }
+export declare interface EnginesControllerWeb {
+    attach(): void;
+    detach(): void;
+    onListenEvents(onSuccess: (p0: Nullable<any>) => void, onError: (p0: Error) => void, onComplete: () => void): void;
+    onMethodCall(name: string, arguments: Nullable<any>): Promise<Nullable<any>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly EnginesControllerWeb: unique symbol;
+    };
+}
+export declare function createEnginesControllerWeb(): EnginesControllerWeb;
 export as namespace Logic_Debertz_client_plugin;