import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Empty } from "./google/protobuf/empty";
export declare const protobufPackage = "Cratis.Chronicle.Contracts.Clients";
export interface CompatibilityRequest {
    ClientType: string;
    ClientVersion: string;
    ProtocolVersion: string;
    DescriptorSet: Buffer;
}
export interface CompatibilityResponse {
    IsCompatible: boolean;
    Incompatibilities: string[];
    ServerVersion: string;
    ServerProtocolVersion: string;
}
export interface ConnectRequest {
    ConnectionId: string;
    ClientVersion: string;
    IsRunningWithDebugger: boolean;
    ProcessId: number;
    ProcessPath: string;
    MachineName: string;
    ClientType: string;
}
export interface ConnectedClient {
    ConnectionId: string;
    Version: string;
    LastSeen: SerializableDateTimeOffset | undefined;
    IsRunningWithDebugger: boolean;
    SiloAddress: string;
    ProcessId: number;
    ProcessPath: string;
    MachineName: string;
    ClientType: string;
}
export interface ConnectionKeepAlive {
    ConnectionId: string;
}
export interface DescriptorSetResponse {
    SchemaDefinition: string;
}
export interface IEnumerableConnectedClient {
    items: ConnectedClient[];
}
export interface SerializableDateTimeOffset {
    Value: string;
}
export declare const CompatibilityRequest: MessageFns<CompatibilityRequest>;
export declare const CompatibilityResponse: MessageFns<CompatibilityResponse>;
export declare const ConnectRequest: MessageFns<ConnectRequest>;
export declare const ConnectedClient: MessageFns<ConnectedClient>;
export declare const ConnectionKeepAlive: MessageFns<ConnectionKeepAlive>;
export declare const DescriptorSetResponse: MessageFns<DescriptorSetResponse>;
export declare const IEnumerableConnectedClient: MessageFns<IEnumerableConnectedClient>;
export declare const SerializableDateTimeOffset: MessageFns<SerializableDateTimeOffset>;
export type ConnectionServiceDefinition = typeof ConnectionServiceDefinition;
export declare const ConnectionServiceDefinition: {
    readonly name: "ConnectionService";
    readonly fullName: "Cratis.Chronicle.Contracts.Clients.ConnectionService";
    readonly methods: {
        readonly checkCompatibility: {
            readonly name: "CheckCompatibility";
            readonly requestType: typeof CompatibilityRequest;
            readonly requestStream: false;
            readonly responseType: typeof CompatibilityResponse;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly connect: {
            readonly name: "Connect";
            readonly requestType: typeof ConnectRequest;
            readonly requestStream: false;
            readonly responseType: typeof ConnectionKeepAlive;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly connectionKeepAlive: {
            readonly name: "ConnectionKeepAlive";
            readonly requestType: typeof ConnectionKeepAlive;
            readonly requestStream: false;
            readonly responseType: typeof Empty;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly getConnectedClients: {
            readonly name: "GetConnectedClients";
            readonly requestType: typeof Empty;
            readonly requestStream: false;
            readonly responseType: typeof IEnumerableConnectedClient;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly getDescriptorSet: {
            readonly name: "GetDescriptorSet";
            readonly requestType: typeof Empty;
            readonly requestStream: false;
            readonly responseType: typeof DescriptorSetResponse;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly observeConnectedClients: {
            readonly name: "ObserveConnectedClients";
            readonly requestType: typeof Empty;
            readonly requestStream: false;
            readonly responseType: typeof IEnumerableConnectedClient;
            readonly responseStream: true;
            readonly options: {};
        };
    };
};
export interface ConnectionServiceImplementation<CallContextExt = {}> {
    checkCompatibility(request: CompatibilityRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CompatibilityResponse>>;
    connect(request: ConnectRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<ConnectionKeepAlive>>;
    connectionKeepAlive(request: ConnectionKeepAlive, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
    getConnectedClients(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<IEnumerableConnectedClient>>;
    getDescriptorSet(request: Empty, context: CallContext & CallContextExt): Promise<DeepPartial<DescriptorSetResponse>>;
    observeConnectedClients(request: Empty, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<IEnumerableConnectedClient>>;
}
export interface ConnectionServiceClient<CallOptionsExt = {}> {
    checkCompatibility(request: DeepPartial<CompatibilityRequest>, options?: CallOptions & CallOptionsExt): Promise<CompatibilityResponse>;
    connect(request: DeepPartial<ConnectRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<ConnectionKeepAlive>;
    connectionKeepAlive(request: DeepPartial<ConnectionKeepAlive>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
    getConnectedClients(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<IEnumerableConnectedClient>;
    getDescriptorSet(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): Promise<DescriptorSetResponse>;
    observeConnectedClients(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): AsyncIterable<IEnumerableConnectedClient>;
}
type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export type ServerStreamingMethodResult<Response> = {
    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
};
export interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial<T>): T;
    fromPartial(object: DeepPartial<T>): T;
}
export {};
//# sourceMappingURL=clients.d.ts.map