import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Guid } from "./protobuf-net/bcl";
export declare const protobufPackage = "Cratis.Chronicle.Contracts.EventTypes";
export declare enum EventTypeOwner {
    None = 0,
    Client = 1,
    Server = 2,
    UNRECOGNIZED = -1
}
export declare function eventTypeOwnerFromJSON(object: any): EventTypeOwner;
export declare function eventTypeOwnerToJSON(object: EventTypeOwner): string;
export declare enum EventTypeSource {
    EVENT_TYPE_SOURCE_Unknown = 0,
    Code = 1,
    User = 2,
    UNRECOGNIZED = -1
}
export declare function eventTypeSourceFromJSON(object: any): EventTypeSource;
export declare function eventTypeSourceToJSON(object: EventTypeSource): string;
export declare enum ValidationResultSeverity {
    VALIDATION_RESULT_SEVERITY_Unknown = 0,
    Information = 1,
    Warning = 2,
    Error = 3,
    UNRECOGNIZED = -1
}
export declare function validationResultSeverityFromJSON(object: any): ValidationResultSeverity;
export declare function validationResultSeverityToJSON(object: ValidationResultSeverity): string;
export interface AllEventTypeGenerationsRequest {
    EventStore: string;
    EventTypeId: string;
}
export interface AllEventTypesRequest {
    EventStore: string;
}
export interface CommandResult {
    CorrelationId: Guid | undefined;
    IsAuthorized: boolean;
    ValidationResults: ValidationResult[];
    ExceptionMessages: string[];
    ExceptionStackTrace: string;
    AuthorizationFailureReason: string;
}
export interface CreateEventTypeRequest {
    EventStore: string;
    Name: string;
}
export interface EventType {
    Id: string;
    Generation: number;
    Tombstone: boolean;
}
export interface EventTypeDetailsResponse {
    Type: EventType | undefined;
    Owner: EventTypeOwner;
    Source: EventTypeSource;
    Schema: string;
    Id: string;
}
export interface EventTypeGenerationDefinition {
    Generation: number;
    Schema: string;
}
export interface EventTypeMigrationDefinition {
    FromGeneration: number;
    ToGeneration: number;
    Operations: EventTypeMigrationOperation[];
    UpcastJmesPath: string;
    DowncastJmesPath: string;
}
export interface EventTypeMigrationOperation {
    Operation: string;
    Details: string;
}
export interface EventTypeRegistration {
    Type: EventType | undefined;
    Schema: string;
    Generations: EventTypeGenerationDefinition[];
    Migrations: EventTypeMigrationDefinition[];
    EventStore: string;
}
export interface ObserveEventTypesRequest {
    EventStore: string;
}
export interface QueryResultIEnumerableEventTypeDetailsResponse {
    CorrelationId: Guid | undefined;
    IsAuthorized: boolean;
    ValidationResults: ValidationResult[];
    ExceptionMessages: string[];
    ExceptionStackTrace: string;
    Data: EventTypeDetailsResponse[];
}
export interface RegisterEventTypesRequest {
    EventStore: string;
    Types: EventTypeRegistration[];
    DisableValidation: boolean;
}
export interface RegisterSingleEventTypeRequest {
    EventStore: string;
    Type: EventTypeRegistration | undefined;
}
export interface ValidationResult {
    Severity: ValidationResultSeverity;
    Message: string;
    Members: string[];
}
export declare const AllEventTypeGenerationsRequest: MessageFns<AllEventTypeGenerationsRequest>;
export declare const AllEventTypesRequest: MessageFns<AllEventTypesRequest>;
export declare const CommandResult: MessageFns<CommandResult>;
export declare const CreateEventTypeRequest: MessageFns<CreateEventTypeRequest>;
export declare const EventType: MessageFns<EventType>;
export declare const EventTypeDetailsResponse: MessageFns<EventTypeDetailsResponse>;
export declare const EventTypeGenerationDefinition: MessageFns<EventTypeGenerationDefinition>;
export declare const EventTypeMigrationDefinition: MessageFns<EventTypeMigrationDefinition>;
export declare const EventTypeMigrationOperation: MessageFns<EventTypeMigrationOperation>;
export declare const EventTypeRegistration: MessageFns<EventTypeRegistration>;
export declare const ObserveEventTypesRequest: MessageFns<ObserveEventTypesRequest>;
export declare const QueryResultIEnumerableEventTypeDetailsResponse: MessageFns<QueryResultIEnumerableEventTypeDetailsResponse>;
export declare const RegisterEventTypesRequest: MessageFns<RegisterEventTypesRequest>;
export declare const RegisterSingleEventTypeRequest: MessageFns<RegisterSingleEventTypeRequest>;
export declare const ValidationResult: MessageFns<ValidationResult>;
export type EventTypesDefinition = typeof EventTypesDefinition;
export declare const EventTypesDefinition: {
    readonly name: "EventTypes";
    readonly fullName: "Cratis.Chronicle.Contracts.EventTypes.EventTypes";
    readonly methods: {
        readonly allEventTypeGenerations: {
            readonly name: "AllEventTypeGenerations";
            readonly requestType: typeof AllEventTypeGenerationsRequest;
            readonly requestStream: false;
            readonly responseType: typeof QueryResultIEnumerableEventTypeDetailsResponse;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly allEventTypes: {
            readonly name: "AllEventTypes";
            readonly requestType: typeof AllEventTypesRequest;
            readonly requestStream: false;
            readonly responseType: typeof QueryResultIEnumerableEventTypeDetailsResponse;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly createEventType: {
            readonly name: "CreateEventType";
            readonly requestType: typeof CreateEventTypeRequest;
            readonly requestStream: false;
            readonly responseType: typeof CommandResult;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly observeEventTypes: {
            readonly name: "ObserveEventTypes";
            readonly requestType: typeof ObserveEventTypesRequest;
            readonly requestStream: false;
            readonly responseType: typeof QueryResultIEnumerableEventTypeDetailsResponse;
            readonly responseStream: true;
            readonly options: {};
        };
        readonly registerEventTypes: {
            readonly name: "RegisterEventTypes";
            readonly requestType: typeof RegisterEventTypesRequest;
            readonly requestStream: false;
            readonly responseType: typeof CommandResult;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly registerSingleEventType: {
            readonly name: "RegisterSingleEventType";
            readonly requestType: typeof RegisterSingleEventTypeRequest;
            readonly requestStream: false;
            readonly responseType: typeof CommandResult;
            readonly responseStream: false;
            readonly options: {};
        };
    };
};
export interface EventTypesServiceImplementation<CallContextExt = {}> {
    allEventTypeGenerations(request: AllEventTypeGenerationsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
    allEventTypes(request: AllEventTypesRequest, context: CallContext & CallContextExt): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
    createEventType(request: CreateEventTypeRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CommandResult>>;
    observeEventTypes(request: ObserveEventTypesRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
    registerEventTypes(request: RegisterEventTypesRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CommandResult>>;
    registerSingleEventType(request: RegisterSingleEventTypeRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CommandResult>>;
}
export interface EventTypesClient<CallOptionsExt = {}> {
    allEventTypeGenerations(request: DeepPartial<AllEventTypeGenerationsRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
    allEventTypes(request: DeepPartial<AllEventTypesRequest>, options?: CallOptions & CallOptionsExt): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
    createEventType(request: DeepPartial<CreateEventTypeRequest>, options?: CallOptions & CallOptionsExt): Promise<CommandResult>;
    observeEventTypes(request: DeepPartial<ObserveEventTypesRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<QueryResultIEnumerableEventTypeDetailsResponse>;
    registerEventTypes(request: DeepPartial<RegisterEventTypesRequest>, options?: CallOptions & CallOptionsExt): Promise<CommandResult>;
    registerSingleEventType(request: DeepPartial<RegisterSingleEventTypeRequest>, options?: CallOptions & CallOptionsExt): Promise<CommandResult>;
}
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=eventtypes.d.ts.map