// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// source: cerbos/request/v1/request.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { Duration } from "../../../google/protobuf/duration";
import { Value } from "../../../google/protobuf/struct";
import { Timestamp } from "../../../google/protobuf/timestamp";
import {
  PlanResourcesInput_Resource,
  Principal,
  Resource,
} from "../../engine/v1/engine";
import { Policy } from "../../policy/v1/policy";
import { Schema } from "../../schema/v1/schema";

export const protobufPackage = "cerbos.request.v1";

export interface PlanResourcesRequest {
  requestId: string;
  action: string;
  actions: string[];
  principal: Principal | undefined;
  resource: PlanResourcesInput_Resource | undefined;
  auxData: AuxData | undefined;
  includeMeta: boolean;
}

export interface CheckResourceSetRequest {
  requestId: string;
  actions: string[];
  principal: Principal | undefined;
  resource: ResourceSet | undefined;
  includeMeta: boolean;
  auxData: AuxData | undefined;
}

export interface ResourceSet {
  kind: string;
  policyVersion: string;
  instances: { [key: string]: AttributesMap };
  scope: string;
}

export interface ResourceSet_InstancesEntry {
  key: string;
  value: AttributesMap | undefined;
}

export interface AttributesMap {
  attr: { [key: string]: any | undefined };
}

export interface AttributesMap_AttrEntry {
  key: string;
  value: any | undefined;
}

export interface CheckResourceBatchRequest {
  requestId: string;
  principal: Principal | undefined;
  resources: CheckResourceBatchRequest_BatchEntry[];
  auxData: AuxData | undefined;
}

export interface CheckResourceBatchRequest_BatchEntry {
  actions: string[];
  resource: Resource | undefined;
}

export interface CheckResourcesRequest {
  requestId: string;
  includeMeta: boolean;
  principal: Principal | undefined;
  resources: CheckResourcesRequest_ResourceEntry[];
  auxData: AuxData | undefined;
}

export interface CheckResourcesRequest_ResourceEntry {
  actions: string[];
  resource: Resource | undefined;
}

export interface AuxData {
  jwt: AuxData_JWT | undefined;
}

export interface AuxData_JWT {
  token: string;
  keySetId: string;
}

export interface AddOrUpdatePolicyRequest {
  policies: Policy[];
}

export interface ListAuditLogEntriesRequest {
  kind: ListAuditLogEntriesRequest_Kind;
  filter?:
    | { $case: "tail"; tail: number }
    | { $case: "between"; between: ListAuditLogEntriesRequest_TimeRange }
    | { $case: "since"; since: Duration }
    | { $case: "lookup"; lookup: string }
    | undefined;
}

export enum ListAuditLogEntriesRequest_Kind {
  KIND_UNSPECIFIED = 0,
  KIND_ACCESS = 1,
  KIND_DECISION = 2,
}

export interface ListAuditLogEntriesRequest_TimeRange {
  start: Date | undefined;
  end: Date | undefined;
}

export interface ServerInfoRequest {}

export interface ListPoliciesRequest {
  includeDisabled: boolean;
  nameRegexp: string;
  scopeRegexp: string;
  versionRegexp: string;
  policyId: string[];
}

export interface GetPolicyRequest {
  id: string[];
}

export interface DisablePolicyRequest {
  id: string[];
}

export interface EnablePolicyRequest {
  id: string[];
}

export interface InspectPoliciesRequest {
  includeDisabled: boolean;
  nameRegexp: string;
  scopeRegexp: string;
  versionRegexp: string;
  policyId: string[];
}

export interface AddOrUpdateSchemaRequest {
  schemas: Schema[];
}

export interface ListSchemasRequest {}

export interface GetSchemaRequest {
  id: string[];
}

export interface DeleteSchemaRequest {
  id: string[];
}

export interface ReloadStoreRequest {
  wait: boolean;
}

function createBasePlanResourcesRequest(): PlanResourcesRequest {
  return {
    requestId: "",
    action: "",
    actions: [],
    principal: undefined,
    resource: undefined,
    auxData: undefined,
    includeMeta: false,
  };
}

export const PlanResourcesRequest: MessageFns<PlanResourcesRequest> = {
  encode(
    message: PlanResourcesRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.requestId !== "") {
      writer.uint32(10).string(message.requestId);
    }
    if (message.action !== "") {
      writer.uint32(18).string(message.action);
    }
    for (const v of message.actions) {
      writer.uint32(58).string(v!);
    }
    if (message.principal !== undefined) {
      Principal.encode(message.principal, writer.uint32(26).fork()).join();
    }
    if (message.resource !== undefined) {
      PlanResourcesInput_Resource.encode(
        message.resource,
        writer.uint32(34).fork(),
      ).join();
    }
    if (message.auxData !== undefined) {
      AuxData.encode(message.auxData, writer.uint32(42).fork()).join();
    }
    if (message.includeMeta !== false) {
      writer.uint32(48).bool(message.includeMeta);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): PlanResourcesRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBasePlanResourcesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

          message.action = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }

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

          message.principal = Principal.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.resource = PlanResourcesInput_Resource.decode(
            reader,
            reader.uint32(),
          );
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.auxData = AuxData.decode(reader, reader.uint32());
          continue;
        }
        case 6: {
          if (tag !== 48) {
            break;
          }

          message.includeMeta = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseCheckResourceSetRequest(): CheckResourceSetRequest {
  return {
    requestId: "",
    actions: [],
    principal: undefined,
    resource: undefined,
    includeMeta: false,
    auxData: undefined,
  };
}

export const CheckResourceSetRequest: MessageFns<CheckResourceSetRequest> = {
  encode(
    message: CheckResourceSetRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.requestId !== "") {
      writer.uint32(10).string(message.requestId);
    }
    for (const v of message.actions) {
      writer.uint32(18).string(v!);
    }
    if (message.principal !== undefined) {
      Principal.encode(message.principal, writer.uint32(26).fork()).join();
    }
    if (message.resource !== undefined) {
      ResourceSet.encode(message.resource, writer.uint32(34).fork()).join();
    }
    if (message.includeMeta !== false) {
      writer.uint32(40).bool(message.includeMeta);
    }
    if (message.auxData !== undefined) {
      AuxData.encode(message.auxData, writer.uint32(50).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): CheckResourceSetRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseCheckResourceSetRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

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

          message.principal = Principal.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.resource = ResourceSet.decode(reader, reader.uint32());
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.includeMeta = reader.bool();
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.auxData = AuxData.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseResourceSet(): ResourceSet {
  return { kind: "", policyVersion: "", instances: {}, scope: "" };
}

export const ResourceSet: MessageFns<ResourceSet> = {
  encode(
    message: ResourceSet,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.kind !== "") {
      writer.uint32(10).string(message.kind);
    }
    if (message.policyVersion !== "") {
      writer.uint32(18).string(message.policyVersion);
    }
    Object.entries(message.instances).forEach(([key, value]) => {
      ResourceSet_InstancesEntry.encode(
        { key: key as any, value },
        writer.uint32(26).fork(),
      ).join();
    });
    if (message.scope !== "") {
      writer.uint32(34).string(message.scope);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ResourceSet {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseResourceSet();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

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

          const entry3 = ResourceSet_InstancesEntry.decode(
            reader,
            reader.uint32(),
          );
          if (entry3.value !== undefined) {
            message.instances[entry3.key] = entry3.value;
          }
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.scope = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseResourceSet_InstancesEntry(): ResourceSet_InstancesEntry {
  return { key: "", value: undefined };
}

export const ResourceSet_InstancesEntry: MessageFns<ResourceSet_InstancesEntry> =
  {
    encode(
      message: ResourceSet_InstancesEntry,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      if (message.key !== "") {
        writer.uint32(10).string(message.key);
      }
      if (message.value !== undefined) {
        AttributesMap.encode(message.value, writer.uint32(18).fork()).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): ResourceSet_InstancesEntry {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseResourceSet_InstancesEntry();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

            message.value = AttributesMap.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseAttributesMap(): AttributesMap {
  return { attr: {} };
}

export const AttributesMap: MessageFns<AttributesMap> = {
  encode(
    message: AttributesMap,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    Object.entries(message.attr).forEach(([key, value]) => {
      if (value !== undefined) {
        AttributesMap_AttrEntry.encode(
          { key: key as any, value },
          writer.uint32(10).fork(),
        ).join();
      }
    });
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AttributesMap {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAttributesMap();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          const entry1 = AttributesMap_AttrEntry.decode(
            reader,
            reader.uint32(),
          );
          if (entry1.value !== undefined) {
            message.attr[entry1.key] = entry1.value;
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseAttributesMap_AttrEntry(): AttributesMap_AttrEntry {
  return { key: "", value: undefined };
}

export const AttributesMap_AttrEntry: MessageFns<AttributesMap_AttrEntry> = {
  encode(
    message: AttributesMap_AttrEntry,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== undefined) {
      Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): AttributesMap_AttrEntry {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAttributesMap_AttrEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

          message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseCheckResourceBatchRequest(): CheckResourceBatchRequest {
  return {
    requestId: "",
    principal: undefined,
    resources: [],
    auxData: undefined,
  };
}

export const CheckResourceBatchRequest: MessageFns<CheckResourceBatchRequest> =
  {
    encode(
      message: CheckResourceBatchRequest,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      if (message.requestId !== "") {
        writer.uint32(10).string(message.requestId);
      }
      if (message.principal !== undefined) {
        Principal.encode(message.principal, writer.uint32(18).fork()).join();
      }
      for (const v of message.resources) {
        CheckResourceBatchRequest_BatchEntry.encode(
          v!,
          writer.uint32(26).fork(),
        ).join();
      }
      if (message.auxData !== undefined) {
        AuxData.encode(message.auxData, writer.uint32(34).fork()).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): CheckResourceBatchRequest {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseCheckResourceBatchRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

            message.principal = Principal.decode(reader, reader.uint32());
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.resources.push(
              CheckResourceBatchRequest_BatchEntry.decode(
                reader,
                reader.uint32(),
              ),
            );
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.auxData = AuxData.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseCheckResourceBatchRequest_BatchEntry(): CheckResourceBatchRequest_BatchEntry {
  return { actions: [], resource: undefined };
}

export const CheckResourceBatchRequest_BatchEntry: MessageFns<CheckResourceBatchRequest_BatchEntry> =
  {
    encode(
      message: CheckResourceBatchRequest_BatchEntry,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      for (const v of message.actions) {
        writer.uint32(10).string(v!);
      }
      if (message.resource !== undefined) {
        Resource.encode(message.resource, writer.uint32(18).fork()).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): CheckResourceBatchRequest_BatchEntry {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseCheckResourceBatchRequest_BatchEntry();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

            message.resource = Resource.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseCheckResourcesRequest(): CheckResourcesRequest {
  return {
    requestId: "",
    includeMeta: false,
    principal: undefined,
    resources: [],
    auxData: undefined,
  };
}

export const CheckResourcesRequest: MessageFns<CheckResourcesRequest> = {
  encode(
    message: CheckResourcesRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.requestId !== "") {
      writer.uint32(10).string(message.requestId);
    }
    if (message.includeMeta !== false) {
      writer.uint32(16).bool(message.includeMeta);
    }
    if (message.principal !== undefined) {
      Principal.encode(message.principal, writer.uint32(26).fork()).join();
    }
    for (const v of message.resources) {
      CheckResourcesRequest_ResourceEntry.encode(
        v!,
        writer.uint32(34).fork(),
      ).join();
    }
    if (message.auxData !== undefined) {
      AuxData.encode(message.auxData, writer.uint32(42).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): CheckResourcesRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseCheckResourcesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

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

          message.principal = Principal.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.resources.push(
            CheckResourcesRequest_ResourceEntry.decode(reader, reader.uint32()),
          );
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.auxData = AuxData.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseCheckResourcesRequest_ResourceEntry(): CheckResourcesRequest_ResourceEntry {
  return { actions: [], resource: undefined };
}

export const CheckResourcesRequest_ResourceEntry: MessageFns<CheckResourcesRequest_ResourceEntry> =
  {
    encode(
      message: CheckResourcesRequest_ResourceEntry,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      for (const v of message.actions) {
        writer.uint32(10).string(v!);
      }
      if (message.resource !== undefined) {
        Resource.encode(message.resource, writer.uint32(18).fork()).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): CheckResourcesRequest_ResourceEntry {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseCheckResourcesRequest_ResourceEntry();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

            message.resource = Resource.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseAuxData(): AuxData {
  return { jwt: undefined };
}

export const AuxData: MessageFns<AuxData> = {
  encode(
    message: AuxData,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.jwt !== undefined) {
      AuxData_JWT.encode(message.jwt, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AuxData {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAuxData();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.jwt = AuxData_JWT.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseAuxData_JWT(): AuxData_JWT {
  return { token: "", keySetId: "" };
}

export const AuxData_JWT: MessageFns<AuxData_JWT> = {
  encode(
    message: AuxData_JWT,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.token !== "") {
      writer.uint32(10).string(message.token);
    }
    if (message.keySetId !== "") {
      writer.uint32(18).string(message.keySetId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): AuxData_JWT {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAuxData_JWT();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

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

          message.keySetId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseAddOrUpdatePolicyRequest(): AddOrUpdatePolicyRequest {
  return { policies: [] };
}

export const AddOrUpdatePolicyRequest: MessageFns<AddOrUpdatePolicyRequest> = {
  encode(
    message: AddOrUpdatePolicyRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.policies) {
      Policy.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): AddOrUpdatePolicyRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddOrUpdatePolicyRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.policies.push(Policy.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseListAuditLogEntriesRequest(): ListAuditLogEntriesRequest {
  return { kind: 0, filter: undefined };
}

export const ListAuditLogEntriesRequest: MessageFns<ListAuditLogEntriesRequest> =
  {
    encode(
      message: ListAuditLogEntriesRequest,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      if (message.kind !== 0) {
        writer.uint32(8).int32(message.kind);
      }
      switch (message.filter?.$case) {
        case "tail":
          writer.uint32(16).uint32(message.filter.tail);
          break;
        case "between":
          ListAuditLogEntriesRequest_TimeRange.encode(
            message.filter.between,
            writer.uint32(26).fork(),
          ).join();
          break;
        case "since":
          Duration.encode(
            message.filter.since,
            writer.uint32(34).fork(),
          ).join();
          break;
        case "lookup":
          writer.uint32(42).string(message.filter.lookup);
          break;
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): ListAuditLogEntriesRequest {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseListAuditLogEntriesRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }

            message.kind = reader.int32() as any;
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.filter = { $case: "tail", tail: reader.uint32() };
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.filter = {
              $case: "between",
              between: ListAuditLogEntriesRequest_TimeRange.decode(
                reader,
                reader.uint32(),
              ),
            };
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.filter = {
              $case: "since",
              since: Duration.decode(reader, reader.uint32()),
            };
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.filter = { $case: "lookup", lookup: reader.string() };
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseListAuditLogEntriesRequest_TimeRange(): ListAuditLogEntriesRequest_TimeRange {
  return { start: undefined, end: undefined };
}

export const ListAuditLogEntriesRequest_TimeRange: MessageFns<ListAuditLogEntriesRequest_TimeRange> =
  {
    encode(
      message: ListAuditLogEntriesRequest_TimeRange,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      if (message.start !== undefined) {
        Timestamp.encode(
          toTimestamp(message.start),
          writer.uint32(10).fork(),
        ).join();
      }
      if (message.end !== undefined) {
        Timestamp.encode(
          toTimestamp(message.end),
          writer.uint32(18).fork(),
        ).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): ListAuditLogEntriesRequest_TimeRange {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      let end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseListAuditLogEntriesRequest_TimeRange();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.start = fromTimestamp(
              Timestamp.decode(reader, reader.uint32()),
            );
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.end = fromTimestamp(
              Timestamp.decode(reader, reader.uint32()),
            );
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

function createBaseServerInfoRequest(): ServerInfoRequest {
  return {};
}

export const ServerInfoRequest: MessageFns<ServerInfoRequest> = {
  encode(
    _: ServerInfoRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ServerInfoRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseServerInfoRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseListPoliciesRequest(): ListPoliciesRequest {
  return {
    includeDisabled: false,
    nameRegexp: "",
    scopeRegexp: "",
    versionRegexp: "",
    policyId: [],
  };
}

export const ListPoliciesRequest: MessageFns<ListPoliciesRequest> = {
  encode(
    message: ListPoliciesRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.includeDisabled !== false) {
      writer.uint32(8).bool(message.includeDisabled);
    }
    if (message.nameRegexp !== "") {
      writer.uint32(18).string(message.nameRegexp);
    }
    if (message.scopeRegexp !== "") {
      writer.uint32(26).string(message.scopeRegexp);
    }
    if (message.versionRegexp !== "") {
      writer.uint32(34).string(message.versionRegexp);
    }
    for (const v of message.policyId) {
      writer.uint32(42).string(v!);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): ListPoliciesRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseListPoliciesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

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

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

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

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

          message.policyId.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseGetPolicyRequest(): GetPolicyRequest {
  return { id: [] };
}

export const GetPolicyRequest: MessageFns<GetPolicyRequest> = {
  encode(
    message: GetPolicyRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.id) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetPolicyRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetPolicyRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseDisablePolicyRequest(): DisablePolicyRequest {
  return { id: [] };
}

export const DisablePolicyRequest: MessageFns<DisablePolicyRequest> = {
  encode(
    message: DisablePolicyRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.id) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): DisablePolicyRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDisablePolicyRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseEnablePolicyRequest(): EnablePolicyRequest {
  return { id: [] };
}

export const EnablePolicyRequest: MessageFns<EnablePolicyRequest> = {
  encode(
    message: EnablePolicyRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.id) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): EnablePolicyRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseEnablePolicyRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseInspectPoliciesRequest(): InspectPoliciesRequest {
  return {
    includeDisabled: false,
    nameRegexp: "",
    scopeRegexp: "",
    versionRegexp: "",
    policyId: [],
  };
}

export const InspectPoliciesRequest: MessageFns<InspectPoliciesRequest> = {
  encode(
    message: InspectPoliciesRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.includeDisabled !== false) {
      writer.uint32(8).bool(message.includeDisabled);
    }
    if (message.nameRegexp !== "") {
      writer.uint32(18).string(message.nameRegexp);
    }
    if (message.scopeRegexp !== "") {
      writer.uint32(26).string(message.scopeRegexp);
    }
    if (message.versionRegexp !== "") {
      writer.uint32(34).string(message.versionRegexp);
    }
    for (const v of message.policyId) {
      writer.uint32(42).string(v!);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): InspectPoliciesRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseInspectPoliciesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

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

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

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

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

          message.policyId.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseAddOrUpdateSchemaRequest(): AddOrUpdateSchemaRequest {
  return { schemas: [] };
}

export const AddOrUpdateSchemaRequest: MessageFns<AddOrUpdateSchemaRequest> = {
  encode(
    message: AddOrUpdateSchemaRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.schemas) {
      Schema.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): AddOrUpdateSchemaRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddOrUpdateSchemaRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.schemas.push(Schema.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseListSchemasRequest(): ListSchemasRequest {
  return {};
}

export const ListSchemasRequest: MessageFns<ListSchemasRequest> = {
  encode(
    _: ListSchemasRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): ListSchemasRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseListSchemasRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseGetSchemaRequest(): GetSchemaRequest {
  return { id: [] };
}

export const GetSchemaRequest: MessageFns<GetSchemaRequest> = {
  encode(
    message: GetSchemaRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.id) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetSchemaRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetSchemaRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseDeleteSchemaRequest(): DeleteSchemaRequest {
  return { id: [] };
}

export const DeleteSchemaRequest: MessageFns<DeleteSchemaRequest> = {
  encode(
    message: DeleteSchemaRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.id) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): DeleteSchemaRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDeleteSchemaRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.id.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseReloadStoreRequest(): ReloadStoreRequest {
  return { wait: false };
}

export const ReloadStoreRequest: MessageFns<ReloadStoreRequest> = {
  encode(
    message: ReloadStoreRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.wait !== false) {
      writer.uint32(8).bool(message.wait);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): ReloadStoreRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseReloadStoreRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.wait = reader.bool();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function toTimestamp(date: Date): Timestamp {
  const seconds = Math.trunc(date.getTime() / 1_000).toString();
  const nanos = (date.getTime() % 1_000) * 1_000_000;
  return { seconds, nanos };
}

function fromTimestamp(t: Timestamp): Date {
  let millis = (globalThis.Number(t.seconds) || 0) * 1_000;
  millis += (t.nanos || 0) / 1_000_000;
  return new globalThis.Date(millis);
}

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
}