// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.12.4
//   protoc               v5.28.3
// source: compliance.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Empty } from "./google/protobuf/empty";

export const protobufPackage = "Cratis.Chronicle.Contracts.Compliance";

export interface AllowNewEncryptionKeyRequest {
  EventStore: string;
  Namespace: string;
  Identifier: string;
}

export interface DeleteEncryptionKeyRequest {
  EventStore: string;
  Namespace: string;
  Identifier: string;
}

export interface ReleaseRequest {
  EventStore: string;
  Namespace: string;
  Subject: string;
  Schema: string;
  Payload: string;
}

export interface ReleaseResponse {
  Payload: string;
  HasError: boolean;
  Error: string;
}

function createBaseAllowNewEncryptionKeyRequest(): AllowNewEncryptionKeyRequest {
  return { EventStore: "", Namespace: "", Identifier: "" };
}

export const AllowNewEncryptionKeyRequest: MessageFns<AllowNewEncryptionKeyRequest> = {
  encode(message: AllowNewEncryptionKeyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.Identifier !== "") {
      writer.uint32(26).string(message.Identifier);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AllowNewEncryptionKeyRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseAllowNewEncryptionKeyRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Identifier = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): AllowNewEncryptionKeyRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
    };
  },

  toJSON(message: AllowNewEncryptionKeyRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    return obj;
  },

  create(base?: DeepPartial<AllowNewEncryptionKeyRequest>): AllowNewEncryptionKeyRequest {
    return AllowNewEncryptionKeyRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<AllowNewEncryptionKeyRequest>): AllowNewEncryptionKeyRequest {
    const message = createBaseAllowNewEncryptionKeyRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.Identifier = object.Identifier ?? "";
    return message;
  },
};

function createBaseDeleteEncryptionKeyRequest(): DeleteEncryptionKeyRequest {
  return { EventStore: "", Namespace: "", Identifier: "" };
}

export const DeleteEncryptionKeyRequest: MessageFns<DeleteEncryptionKeyRequest> = {
  encode(message: DeleteEncryptionKeyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.Identifier !== "") {
      writer.uint32(26).string(message.Identifier);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): DeleteEncryptionKeyRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseDeleteEncryptionKeyRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Identifier = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): DeleteEncryptionKeyRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
    };
  },

  toJSON(message: DeleteEncryptionKeyRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    return obj;
  },

  create(base?: DeepPartial<DeleteEncryptionKeyRequest>): DeleteEncryptionKeyRequest {
    return DeleteEncryptionKeyRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<DeleteEncryptionKeyRequest>): DeleteEncryptionKeyRequest {
    const message = createBaseDeleteEncryptionKeyRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.Identifier = object.Identifier ?? "";
    return message;
  },
};

function createBaseReleaseRequest(): ReleaseRequest {
  return { EventStore: "", Namespace: "", Subject: "", Schema: "", Payload: "" };
}

export const ReleaseRequest: MessageFns<ReleaseRequest> = {
  encode(message: ReleaseRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.Subject !== "") {
      writer.uint32(26).string(message.Subject);
    }
    if (message.Schema !== "") {
      writer.uint32(34).string(message.Schema);
    }
    if (message.Payload !== "") {
      writer.uint32(42).string(message.Payload);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReleaseRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReleaseRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Subject = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.Schema = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.Payload = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReleaseRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      Subject: isSet(object.Subject) ? globalThis.String(object.Subject) : "",
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Payload: isSet(object.Payload) ? globalThis.String(object.Payload) : "",
    };
  },

  toJSON(message: ReleaseRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.Subject !== "") {
      obj.Subject = message.Subject;
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Payload !== "") {
      obj.Payload = message.Payload;
    }
    return obj;
  },

  create(base?: DeepPartial<ReleaseRequest>): ReleaseRequest {
    return ReleaseRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReleaseRequest>): ReleaseRequest {
    const message = createBaseReleaseRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.Subject = object.Subject ?? "";
    message.Schema = object.Schema ?? "";
    message.Payload = object.Payload ?? "";
    return message;
  },
};

function createBaseReleaseResponse(): ReleaseResponse {
  return { Payload: "", HasError: false, Error: "" };
}

export const ReleaseResponse: MessageFns<ReleaseResponse> = {
  encode(message: ReleaseResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Payload !== "") {
      writer.uint32(10).string(message.Payload);
    }
    if (message.HasError !== false) {
      writer.uint32(16).bool(message.HasError);
    }
    if (message.Error !== "") {
      writer.uint32(26).string(message.Error);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReleaseResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReleaseResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Payload = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.HasError = reader.bool();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Error = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReleaseResponse {
    return {
      Payload: isSet(object.Payload) ? globalThis.String(object.Payload) : "",
      HasError: isSet(object.HasError) ? globalThis.Boolean(object.HasError) : false,
      Error: isSet(object.Error) ? globalThis.String(object.Error) : "",
    };
  },

  toJSON(message: ReleaseResponse): unknown {
    const obj: any = {};
    if (message.Payload !== "") {
      obj.Payload = message.Payload;
    }
    if (message.HasError !== false) {
      obj.HasError = message.HasError;
    }
    if (message.Error !== "") {
      obj.Error = message.Error;
    }
    return obj;
  },

  create(base?: DeepPartial<ReleaseResponse>): ReleaseResponse {
    return ReleaseResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReleaseResponse>): ReleaseResponse {
    const message = createBaseReleaseResponse();
    message.Payload = object.Payload ?? "";
    message.HasError = object.HasError ?? false;
    message.Error = object.Error ?? "";
    return message;
  },
};

export type ComplianceDefinition = typeof ComplianceDefinition;
export const ComplianceDefinition = {
  name: "Compliance",
  fullName: "Cratis.Chronicle.Contracts.Compliance.Compliance",
  methods: {
    allowNewEncryptionKey: {
      name: "AllowNewEncryptionKey",
      requestType: AllowNewEncryptionKeyRequest as typeof AllowNewEncryptionKeyRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    deleteEncryptionKey: {
      name: "DeleteEncryptionKey",
      requestType: DeleteEncryptionKeyRequest as typeof DeleteEncryptionKeyRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    release: {
      name: "Release",
      requestType: ReleaseRequest as typeof ReleaseRequest,
      requestStream: false,
      responseType: ReleaseResponse as typeof ReleaseResponse,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface ComplianceServiceImplementation<CallContextExt = {}> {
  allowNewEncryptionKey(
    request: AllowNewEncryptionKeyRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  deleteEncryptionKey(
    request: DeleteEncryptionKeyRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  release(request: ReleaseRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ReleaseResponse>>;
}

export interface ComplianceClient<CallOptionsExt = {}> {
  allowNewEncryptionKey(
    request: DeepPartial<AllowNewEncryptionKeyRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  deleteEncryptionKey(
    request: DeepPartial<DeleteEncryptionKeyRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  release(request: DeepPartial<ReleaseRequest>, options?: CallOptions & CallOptionsExt): Promise<ReleaseResponse>;
}

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>;

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

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;
}