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.Events.Constraints";
export declare enum ConstraintType {
    Unknown = 0,
    Unique = 1,
    UniqueEventType = 2,
    Schema = 3,
    StreamClosed = 4,
    UNRECOGNIZED = -1
}
export declare function constraintTypeFromJSON(object: any): ConstraintType;
export declare function constraintTypeToJSON(object: ConstraintType): string;
export interface Constraint {
    Name: string;
    Type: ConstraintType;
    RemovedWith: string[];
    Definition: OneOfUniqueConstraintDefinitionUniqueEventTypeConstraintDefinition | undefined;
    Scope: ConstraintScope | undefined;
}
export interface ConstraintScope {
    EventSourceType: string;
    EventStreamType: string;
    EventStreamId: string;
}
export interface OneOfUniqueConstraintDefinitionUniqueEventTypeConstraintDefinition {
    Value0: UniqueConstraintDefinition | undefined;
    Value1: UniqueEventTypeConstraintDefinition | undefined;
}
export interface RegisterConstraintsRequest {
    EventStore: string;
    Constraints: Constraint[];
}
export interface UniqueConstraintDefinition {
    EventDefinitions: UniqueConstraintEventDefinition[];
    IgnoreCasing: boolean;
}
export interface UniqueConstraintEventDefinition {
    EventTypeId: string;
    Properties: string[];
}
export interface UniqueEventTypeConstraintDefinition {
    EventTypeIds: string[];
}
export declare const Constraint: MessageFns<Constraint>;
export declare const ConstraintScope: MessageFns<ConstraintScope>;
export declare const OneOfUniqueConstraintDefinitionUniqueEventTypeConstraintDefinition: MessageFns<OneOfUniqueConstraintDefinitionUniqueEventTypeConstraintDefinition>;
export declare const RegisterConstraintsRequest: MessageFns<RegisterConstraintsRequest>;
export declare const UniqueConstraintDefinition: MessageFns<UniqueConstraintDefinition>;
export declare const UniqueConstraintEventDefinition: MessageFns<UniqueConstraintEventDefinition>;
export declare const UniqueEventTypeConstraintDefinition: MessageFns<UniqueEventTypeConstraintDefinition>;
export type ConstraintsDefinition = typeof ConstraintsDefinition;
export declare const ConstraintsDefinition: {
    readonly name: "Constraints";
    readonly fullName: "Cratis.Chronicle.Contracts.Events.Constraints.Constraints";
    readonly methods: {
        readonly register: {
            readonly name: "Register";
            readonly requestType: typeof RegisterConstraintsRequest;
            readonly requestStream: false;
            readonly responseType: typeof Empty;
            readonly responseStream: false;
            readonly options: {};
        };
    };
};
export interface ConstraintsServiceImplementation<CallContextExt = {}> {
    register(request: RegisterConstraintsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
}
export interface ConstraintsClient<CallOptionsExt = {}> {
    register(request: DeepPartial<RegisterConstraintsRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
}
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 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=events_constraints.d.ts.map