// Warning: (ae-incompatible-release-tags) The symbol "AsyncCall" is marked as @public, but its signature references "_AsyncVersionOf" which is marked as @internal
//
// @public
export function AsyncCall<OtherSideImplementedFunctions = {}>(thisSideImplementation: object | Promise<object> | undefined, options: AsyncCallOptions): _AsyncVersionOf<OtherSideImplementedFunctions>;

// @public
export interface AsyncCallLogLevel {
    beCalled?: boolean;
    localError?: boolean;
    remoteError?: boolean;
    requestReplay?: boolean;
    sendLocalStack?: boolean;
    type?: 'basic' | 'pretty';
}

// @public
export interface AsyncCallOptions {
    channel: CallbackBasedChannel | EventBasedChannel;
    idGenerator?(): string | number;
    key?: string;
    log?: AsyncCallLogLevel | boolean;
    logger?: Console;
    mapError?: ErrorMapFunction<unknown>;
    parameterStructures?: 'by-position' | 'by-name';
    preferLocalImplementation?: boolean;
    preservePauseOnException?: boolean;
    serializer?: Serialization;
    strict?: AsyncCallStrictJSONRPC | boolean;
}

// @public
export interface AsyncCallStrictJSONRPC {
    methodNotFound?: boolean;
    unknownMessage?: boolean;
}

// Warning: (ae-incompatible-release-tags) The symbol "AsyncGeneratorCall" is marked as @public, but its signature references "_AsyncGeneratorVersionOf" which is marked as @internal
//
// @public
export function AsyncGeneratorCall<OtherSideImplementedFunctions = {}>(thisSideImplementation: object | Promise<object> | undefined, options: AsyncCallOptions): _AsyncGeneratorVersionOf<OtherSideImplementedFunctions>;

// @internal
export type _AsyncGeneratorVersionOf<T> = {
    [key in keyof T]: T[key] extends (...args: infer Args) => Iterator<infer Yield, infer Return, infer Next> | AsyncIterator<infer Yield, infer Return, infer Next> ? (...args: Args) => AsyncIterator<_UnboxPromise<Yield>, _UnboxPromise<Return>, _UnboxPromise<Next>> & {
        [Symbol.asyncIterator](): AsyncIterator<_UnboxPromise<Yield>, _UnboxPromise<Return>, _UnboxPromise<Next>>;
    } : T[key];
};

// @internal
export type _AsyncVersionOf<T> = {
    [key in keyof T]: T[key] extends (...args: infer Args) => infer Return ? Return extends PromiseLike<infer U> ? (...args: Args) => Promise<U> : (...args: Args) => Promise<Return> : never;
};

// @public
export function batch<T extends object>(asyncCallInstance: T): [T, () => void, (error?: unknown) => void];

// @public
export interface CallbackBasedChannel<Data = unknown> extends Partial<EventBasedChannel<Data>> {
    setup(jsonRPCHandlerCallback: (jsonRPCPayload: unknown) => Promise<unknown | undefined>, isValidJSONRPCPayload: (data: unknown) => boolean | Promise<boolean>): (() => void) | void;
}

// @public
export interface Console {
    // (undocumented)
    debug?(...args: unknown[]): void;
    // (undocumented)
    error?(...args: unknown[]): void;
    // (undocumented)
    groupCollapsed?(...args: unknown[]): void;
    // (undocumented)
    groupEnd?(...args: unknown[]): void;
    // (undocumented)
    log(...args: unknown[]): void;
    // (undocumented)
    warn?(...args: unknown[]): void;
}

// @public (undocumented)
export type ErrorMapFunction<T = unknown> = (error: unknown, request: Readonly<{
    jsonrpc: '2.0';
    id?: string | number | null;
    method: string;
    params: readonly unknown[] | object;
}>) => {
    code: number;
    message: string;
    data?: T;
};

// @public
export interface EventBasedChannel<Data = unknown> {
    on(listener: (data: Data) => void): void | (() => void);
    send(data: Data): void;
}

// @internal (undocumented)
export type _IgnoreResponse<T> = T extends (...args: infer Args) => unknown ? (...args: Args) => Promise<void> : {
    [key in keyof T]: T[key] extends (...args: infer Args) => unknown ? (...args: Args) => Promise<void> : never;
};

// @public
export const JSONSerialization: (replacerAndReceiver?: [(((key: string, value: any) => any) | undefined)?, (((key: string, value: any) => any) | undefined)?], space?: string | number | undefined, undefinedKeepingBehavior?: 'keep' | 'null' | false) => Serialization;

// @public
export const NoSerialization: Serialization;

// Warning: (ae-incompatible-release-tags) The symbol "notify" is marked as @public, but its signature references "_IgnoreResponse" which is marked as @internal
//
// @public
export function notify<T extends object>(instanceOrFnOnInstance: T): _IgnoreResponse<T>;

// @public
export interface Serialization {
    deserialization(serialized: unknown): unknown | PromiseLike<unknown>;
    serialization(from: any): unknown | PromiseLike<unknown>;
}

// @internal
export type _UnboxPromise<T> = T extends PromiseLike<infer U> ? U : T;