/* eslint-disable */
import _m0 from "protobufjs/minimal";
import { Timestamp } from "../../../google/protobuf/timestamp";
import { Query, Query_Pagination } from "../../../meta/v1/meta";

export const protobufPackage = "dnc.buyer.v1";

export interface IsDNCRequest {
  company_id: string;
  phone_number: string;
}

export interface IsDNCResponse {
  dnc: boolean;
}

export interface AddDisqualifiedRequest {
  company_id: string;
  phone_number: string;
}

export interface AddDisqualifiedResponse {
}

export interface SummaryRequest {
  params: SummaryRequest_SummaryParams | undefined;
  query?: Query | undefined;
}

export interface SummaryRequest_SummaryParams {
  start: Date | undefined;
  end: Date | undefined;
  companies?: SummaryRequest_SummaryParams_Companies | undefined;
}

export interface SummaryRequest_SummaryParams_Companies {
  values: string[];
}

export interface SummaryResponse {
  total_count: number;
  result: SummaryResponse_SummaryRow[];
  pagination?: Query_Pagination | undefined;
}

export interface SummaryResponse_SummaryRow {
  date: Date | undefined;
  count: number;
  disqualified_count: number;
  duplicate_count: number;
  company_id: string;
}

export interface AppendRequest {
  dncs: AppendRequest_DNCRequest[];
}

export interface AppendRequest_DNCRequest {
  company_id: string;
  phone_number: string;
}

export interface AppendResponse {
  created_count: number;
  duplicate_count: number;
}

export interface RemoveRequest {
  dncs: RemoveRequest_DNCRequest[];
}

export interface RemoveRequest_DNCRequest {
  company_id: string;
  phone_number: string;
}

export interface RemoveResponse {
  removed_count: number;
}

export interface ReplaceRequest {
  dncs: ReplaceRequest_DNCRequest[];
}

export interface ReplaceRequest_DNCRequest {
  company_id: string;
  phone_number: string;
}

export interface ReplaceResponse {
  removed_count: number;
}

function createBaseIsDNCRequest(): IsDNCRequest {
  return { company_id: "", phone_number: "" };
}

export const IsDNCRequest = {
  encode(message: IsDNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.company_id !== "") {
      writer.uint32(10).string(message.company_id);
    }
    if (message.phone_number !== "") {
      writer.uint32(18).string(message.phone_number);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): IsDNCRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseIsDNCRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.company_id = reader.string();
          break;
        case 2:
          message.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): IsDNCRequest {
    return {
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
    };
  },

  toJSON(message: IsDNCRequest): unknown {
    const obj: any = {};
    message.company_id !== undefined && (obj.company_id = message.company_id);
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<IsDNCRequest>, I>>(object: I): IsDNCRequest {
    const message = createBaseIsDNCRequest();
    message.company_id = object.company_id ?? "";
    message.phone_number = object.phone_number ?? "";
    return message;
  },
};

function createBaseIsDNCResponse(): IsDNCResponse {
  return { dnc: false };
}

export const IsDNCResponse = {
  encode(message: IsDNCResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.dnc === true) {
      writer.uint32(8).bool(message.dnc);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): IsDNCResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseIsDNCResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.dnc = reader.bool();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): IsDNCResponse {
    return { dnc: isSet(object.dnc) ? Boolean(object.dnc) : false };
  },

  toJSON(message: IsDNCResponse): unknown {
    const obj: any = {};
    message.dnc !== undefined && (obj.dnc = message.dnc);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<IsDNCResponse>, I>>(object: I): IsDNCResponse {
    const message = createBaseIsDNCResponse();
    message.dnc = object.dnc ?? false;
    return message;
  },
};

function createBaseAddDisqualifiedRequest(): AddDisqualifiedRequest {
  return { company_id: "", phone_number: "" };
}

export const AddDisqualifiedRequest = {
  encode(message: AddDisqualifiedRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.company_id !== "") {
      writer.uint32(10).string(message.company_id);
    }
    if (message.phone_number !== "") {
      writer.uint32(18).string(message.phone_number);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): AddDisqualifiedRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddDisqualifiedRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.company_id = reader.string();
          break;
        case 2:
          message.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AddDisqualifiedRequest {
    return {
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
    };
  },

  toJSON(message: AddDisqualifiedRequest): unknown {
    const obj: any = {};
    message.company_id !== undefined && (obj.company_id = message.company_id);
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AddDisqualifiedRequest>, I>>(object: I): AddDisqualifiedRequest {
    const message = createBaseAddDisqualifiedRequest();
    message.company_id = object.company_id ?? "";
    message.phone_number = object.phone_number ?? "";
    return message;
  },
};

function createBaseAddDisqualifiedResponse(): AddDisqualifiedResponse {
  return {};
}

export const AddDisqualifiedResponse = {
  encode(_: AddDisqualifiedResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): AddDisqualifiedResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddDisqualifiedResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(_: any): AddDisqualifiedResponse {
    return {};
  },

  toJSON(_: AddDisqualifiedResponse): unknown {
    const obj: any = {};
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AddDisqualifiedResponse>, I>>(_: I): AddDisqualifiedResponse {
    const message = createBaseAddDisqualifiedResponse();
    return message;
  },
};

function createBaseSummaryRequest(): SummaryRequest {
  return { params: undefined, query: undefined };
}

export const SummaryRequest = {
  encode(message: SummaryRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.params !== undefined) {
      SummaryRequest_SummaryParams.encode(message.params, writer.uint32(10).fork()).ldelim();
    }
    if (message.query !== undefined) {
      Query.encode(message.query, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.params = SummaryRequest_SummaryParams.decode(reader, reader.uint32());
          break;
        case 2:
          message.query = Query.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): SummaryRequest {
    return {
      params: isSet(object.params) ? SummaryRequest_SummaryParams.fromJSON(object.params) : undefined,
      query: isSet(object.query) ? Query.fromJSON(object.query) : undefined,
    };
  },

  toJSON(message: SummaryRequest): unknown {
    const obj: any = {};
    message.params !== undefined &&
      (obj.params = message.params ? SummaryRequest_SummaryParams.toJSON(message.params) : undefined);
    message.query !== undefined && (obj.query = message.query ? Query.toJSON(message.query) : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<SummaryRequest>, I>>(object: I): SummaryRequest {
    const message = createBaseSummaryRequest();
    message.params = (object.params !== undefined && object.params !== null)
      ? SummaryRequest_SummaryParams.fromPartial(object.params)
      : undefined;
    message.query = (object.query !== undefined && object.query !== null) ? Query.fromPartial(object.query) : undefined;
    return message;
  },
};

function createBaseSummaryRequest_SummaryParams(): SummaryRequest_SummaryParams {
  return { start: undefined, end: undefined, companies: undefined };
}

export const SummaryRequest_SummaryParams = {
  encode(message: SummaryRequest_SummaryParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.start !== undefined) {
      Timestamp.encode(toTimestamp(message.start), writer.uint32(10).fork()).ldelim();
    }
    if (message.end !== undefined) {
      Timestamp.encode(toTimestamp(message.end), writer.uint32(18).fork()).ldelim();
    }
    if (message.companies !== undefined) {
      SummaryRequest_SummaryParams_Companies.encode(message.companies, writer.uint32(26).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryRequest_SummaryParams {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest_SummaryParams();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.start = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        case 2:
          message.end = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        case 3:
          message.companies = SummaryRequest_SummaryParams_Companies.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): SummaryRequest_SummaryParams {
    return {
      start: isSet(object.start) ? fromJsonTimestamp(object.start) : undefined,
      end: isSet(object.end) ? fromJsonTimestamp(object.end) : undefined,
      companies: isSet(object.companies)
        ? SummaryRequest_SummaryParams_Companies.fromJSON(object.companies)
        : undefined,
    };
  },

  toJSON(message: SummaryRequest_SummaryParams): unknown {
    const obj: any = {};
    message.start !== undefined && (obj.start = message.start.toISOString());
    message.end !== undefined && (obj.end = message.end.toISOString());
    message.companies !== undefined &&
      (obj.companies = message.companies
        ? SummaryRequest_SummaryParams_Companies.toJSON(message.companies)
        : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<SummaryRequest_SummaryParams>, I>>(object: I): SummaryRequest_SummaryParams {
    const message = createBaseSummaryRequest_SummaryParams();
    message.start = object.start ?? undefined;
    message.end = object.end ?? undefined;
    message.companies = (object.companies !== undefined && object.companies !== null)
      ? SummaryRequest_SummaryParams_Companies.fromPartial(object.companies)
      : undefined;
    return message;
  },
};

function createBaseSummaryRequest_SummaryParams_Companies(): SummaryRequest_SummaryParams_Companies {
  return { values: [] };
}

export const SummaryRequest_SummaryParams_Companies = {
  encode(message: SummaryRequest_SummaryParams_Companies, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    for (const v of message.values) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryRequest_SummaryParams_Companies {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest_SummaryParams_Companies();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.values.push(reader.string());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): SummaryRequest_SummaryParams_Companies {
    return { values: Array.isArray(object?.values) ? object.values.map((e: any) => String(e)) : [] };
  },

  toJSON(message: SummaryRequest_SummaryParams_Companies): unknown {
    const obj: any = {};
    if (message.values) {
      obj.values = message.values.map((e) => e);
    } else {
      obj.values = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<SummaryRequest_SummaryParams_Companies>, I>>(
    object: I,
  ): SummaryRequest_SummaryParams_Companies {
    const message = createBaseSummaryRequest_SummaryParams_Companies();
    message.values = object.values?.map((e) => e) || [];
    return message;
  },
};

function createBaseSummaryResponse(): SummaryResponse {
  return { total_count: 0, result: [], pagination: undefined };
}

export const SummaryResponse = {
  encode(message: SummaryResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.total_count !== 0) {
      writer.uint32(8).uint32(message.total_count);
    }
    for (const v of message.result) {
      SummaryResponse_SummaryRow.encode(v!, writer.uint32(18).fork()).ldelim();
    }
    if (message.pagination !== undefined) {
      Query_Pagination.encode(message.pagination, writer.uint32(26).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.total_count = reader.uint32();
          break;
        case 2:
          message.result.push(SummaryResponse_SummaryRow.decode(reader, reader.uint32()));
          break;
        case 3:
          message.pagination = Query_Pagination.decode(reader, reader.uint32());
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): SummaryResponse {
    return {
      total_count: isSet(object.total_count) ? Number(object.total_count) : 0,
      result: Array.isArray(object?.result)
        ? object.result.map((e: any) => SummaryResponse_SummaryRow.fromJSON(e))
        : [],
      pagination: isSet(object.pagination) ? Query_Pagination.fromJSON(object.pagination) : undefined,
    };
  },

  toJSON(message: SummaryResponse): unknown {
    const obj: any = {};
    message.total_count !== undefined && (obj.total_count = Math.round(message.total_count));
    if (message.result) {
      obj.result = message.result.map((e) => e ? SummaryResponse_SummaryRow.toJSON(e) : undefined);
    } else {
      obj.result = [];
    }
    message.pagination !== undefined &&
      (obj.pagination = message.pagination ? Query_Pagination.toJSON(message.pagination) : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<SummaryResponse>, I>>(object: I): SummaryResponse {
    const message = createBaseSummaryResponse();
    message.total_count = object.total_count ?? 0;
    message.result = object.result?.map((e) => SummaryResponse_SummaryRow.fromPartial(e)) || [];
    message.pagination = (object.pagination !== undefined && object.pagination !== null)
      ? Query_Pagination.fromPartial(object.pagination)
      : undefined;
    return message;
  },
};

function createBaseSummaryResponse_SummaryRow(): SummaryResponse_SummaryRow {
  return { date: undefined, count: 0, disqualified_count: 0, duplicate_count: 0, company_id: "" };
}

export const SummaryResponse_SummaryRow = {
  encode(message: SummaryResponse_SummaryRow, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.date !== undefined) {
      Timestamp.encode(toTimestamp(message.date), writer.uint32(10).fork()).ldelim();
    }
    if (message.count !== 0) {
      writer.uint32(16).uint32(message.count);
    }
    if (message.disqualified_count !== 0) {
      writer.uint32(24).uint32(message.disqualified_count);
    }
    if (message.duplicate_count !== 0) {
      writer.uint32(32).uint32(message.duplicate_count);
    }
    if (message.company_id !== "") {
      writer.uint32(42).string(message.company_id);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryResponse_SummaryRow {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryResponse_SummaryRow();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.date = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
          break;
        case 2:
          message.count = reader.uint32();
          break;
        case 3:
          message.disqualified_count = reader.uint32();
          break;
        case 4:
          message.duplicate_count = reader.uint32();
          break;
        case 5:
          message.company_id = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): SummaryResponse_SummaryRow {
    return {
      date: isSet(object.date) ? fromJsonTimestamp(object.date) : undefined,
      count: isSet(object.count) ? Number(object.count) : 0,
      disqualified_count: isSet(object.disqualified_count) ? Number(object.disqualified_count) : 0,
      duplicate_count: isSet(object.duplicate_count) ? Number(object.duplicate_count) : 0,
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
    };
  },

  toJSON(message: SummaryResponse_SummaryRow): unknown {
    const obj: any = {};
    message.date !== undefined && (obj.date = message.date.toISOString());
    message.count !== undefined && (obj.count = Math.round(message.count));
    message.disqualified_count !== undefined && (obj.disqualified_count = Math.round(message.disqualified_count));
    message.duplicate_count !== undefined && (obj.duplicate_count = Math.round(message.duplicate_count));
    message.company_id !== undefined && (obj.company_id = message.company_id);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<SummaryResponse_SummaryRow>, I>>(object: I): SummaryResponse_SummaryRow {
    const message = createBaseSummaryResponse_SummaryRow();
    message.date = object.date ?? undefined;
    message.count = object.count ?? 0;
    message.disqualified_count = object.disqualified_count ?? 0;
    message.duplicate_count = object.duplicate_count ?? 0;
    message.company_id = object.company_id ?? "";
    return message;
  },
};

function createBaseAppendRequest(): AppendRequest {
  return { dncs: [] };
}

export const AppendRequest = {
  encode(message: AppendRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    for (const v of message.dncs) {
      AppendRequest_DNCRequest.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): AppendRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAppendRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.dncs.push(AppendRequest_DNCRequest.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AppendRequest {
    return {
      dncs: Array.isArray(object?.dncs) ? object.dncs.map((e: any) => AppendRequest_DNCRequest.fromJSON(e)) : [],
    };
  },

  toJSON(message: AppendRequest): unknown {
    const obj: any = {};
    if (message.dncs) {
      obj.dncs = message.dncs.map((e) => e ? AppendRequest_DNCRequest.toJSON(e) : undefined);
    } else {
      obj.dncs = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AppendRequest>, I>>(object: I): AppendRequest {
    const message = createBaseAppendRequest();
    message.dncs = object.dncs?.map((e) => AppendRequest_DNCRequest.fromPartial(e)) || [];
    return message;
  },
};

function createBaseAppendRequest_DNCRequest(): AppendRequest_DNCRequest {
  return { company_id: "", phone_number: "" };
}

export const AppendRequest_DNCRequest = {
  encode(message: AppendRequest_DNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.company_id !== "") {
      writer.uint32(10).string(message.company_id);
    }
    if (message.phone_number !== "") {
      writer.uint32(18).string(message.phone_number);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): AppendRequest_DNCRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAppendRequest_DNCRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.company_id = reader.string();
          break;
        case 2:
          message.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AppendRequest_DNCRequest {
    return {
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
    };
  },

  toJSON(message: AppendRequest_DNCRequest): unknown {
    const obj: any = {};
    message.company_id !== undefined && (obj.company_id = message.company_id);
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AppendRequest_DNCRequest>, I>>(object: I): AppendRequest_DNCRequest {
    const message = createBaseAppendRequest_DNCRequest();
    message.company_id = object.company_id ?? "";
    message.phone_number = object.phone_number ?? "";
    return message;
  },
};

function createBaseAppendResponse(): AppendResponse {
  return { created_count: 0, duplicate_count: 0 };
}

export const AppendResponse = {
  encode(message: AppendResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.created_count !== 0) {
      writer.uint32(8).uint32(message.created_count);
    }
    if (message.duplicate_count !== 0) {
      writer.uint32(16).uint32(message.duplicate_count);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): AppendResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAppendResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.created_count = reader.uint32();
          break;
        case 2:
          message.duplicate_count = reader.uint32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AppendResponse {
    return {
      created_count: isSet(object.created_count) ? Number(object.created_count) : 0,
      duplicate_count: isSet(object.duplicate_count) ? Number(object.duplicate_count) : 0,
    };
  },

  toJSON(message: AppendResponse): unknown {
    const obj: any = {};
    message.created_count !== undefined && (obj.created_count = Math.round(message.created_count));
    message.duplicate_count !== undefined && (obj.duplicate_count = Math.round(message.duplicate_count));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AppendResponse>, I>>(object: I): AppendResponse {
    const message = createBaseAppendResponse();
    message.created_count = object.created_count ?? 0;
    message.duplicate_count = object.duplicate_count ?? 0;
    return message;
  },
};

function createBaseRemoveRequest(): RemoveRequest {
  return { dncs: [] };
}

export const RemoveRequest = {
  encode(message: RemoveRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    for (const v of message.dncs) {
      RemoveRequest_DNCRequest.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): RemoveRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRemoveRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.dncs.push(RemoveRequest_DNCRequest.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): RemoveRequest {
    return {
      dncs: Array.isArray(object?.dncs) ? object.dncs.map((e: any) => RemoveRequest_DNCRequest.fromJSON(e)) : [],
    };
  },

  toJSON(message: RemoveRequest): unknown {
    const obj: any = {};
    if (message.dncs) {
      obj.dncs = message.dncs.map((e) => e ? RemoveRequest_DNCRequest.toJSON(e) : undefined);
    } else {
      obj.dncs = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RemoveRequest>, I>>(object: I): RemoveRequest {
    const message = createBaseRemoveRequest();
    message.dncs = object.dncs?.map((e) => RemoveRequest_DNCRequest.fromPartial(e)) || [];
    return message;
  },
};

function createBaseRemoveRequest_DNCRequest(): RemoveRequest_DNCRequest {
  return { company_id: "", phone_number: "" };
}

export const RemoveRequest_DNCRequest = {
  encode(message: RemoveRequest_DNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.company_id !== "") {
      writer.uint32(10).string(message.company_id);
    }
    if (message.phone_number !== "") {
      writer.uint32(18).string(message.phone_number);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): RemoveRequest_DNCRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRemoveRequest_DNCRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.company_id = reader.string();
          break;
        case 2:
          message.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): RemoveRequest_DNCRequest {
    return {
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
    };
  },

  toJSON(message: RemoveRequest_DNCRequest): unknown {
    const obj: any = {};
    message.company_id !== undefined && (obj.company_id = message.company_id);
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RemoveRequest_DNCRequest>, I>>(object: I): RemoveRequest_DNCRequest {
    const message = createBaseRemoveRequest_DNCRequest();
    message.company_id = object.company_id ?? "";
    message.phone_number = object.phone_number ?? "";
    return message;
  },
};

function createBaseRemoveResponse(): RemoveResponse {
  return { removed_count: 0 };
}

export const RemoveResponse = {
  encode(message: RemoveResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.removed_count !== 0) {
      writer.uint32(8).uint32(message.removed_count);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): RemoveResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseRemoveResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.removed_count = reader.uint32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): RemoveResponse {
    return { removed_count: isSet(object.removed_count) ? Number(object.removed_count) : 0 };
  },

  toJSON(message: RemoveResponse): unknown {
    const obj: any = {};
    message.removed_count !== undefined && (obj.removed_count = Math.round(message.removed_count));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<RemoveResponse>, I>>(object: I): RemoveResponse {
    const message = createBaseRemoveResponse();
    message.removed_count = object.removed_count ?? 0;
    return message;
  },
};

function createBaseReplaceRequest(): ReplaceRequest {
  return { dncs: [] };
}

export const ReplaceRequest = {
  encode(message: ReplaceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    for (const v of message.dncs) {
      ReplaceRequest_DNCRequest.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ReplaceRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseReplaceRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.dncs.push(ReplaceRequest_DNCRequest.decode(reader, reader.uint32()));
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ReplaceRequest {
    return {
      dncs: Array.isArray(object?.dncs) ? object.dncs.map((e: any) => ReplaceRequest_DNCRequest.fromJSON(e)) : [],
    };
  },

  toJSON(message: ReplaceRequest): unknown {
    const obj: any = {};
    if (message.dncs) {
      obj.dncs = message.dncs.map((e) => e ? ReplaceRequest_DNCRequest.toJSON(e) : undefined);
    } else {
      obj.dncs = [];
    }
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<ReplaceRequest>, I>>(object: I): ReplaceRequest {
    const message = createBaseReplaceRequest();
    message.dncs = object.dncs?.map((e) => ReplaceRequest_DNCRequest.fromPartial(e)) || [];
    return message;
  },
};

function createBaseReplaceRequest_DNCRequest(): ReplaceRequest_DNCRequest {
  return { company_id: "", phone_number: "" };
}

export const ReplaceRequest_DNCRequest = {
  encode(message: ReplaceRequest_DNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.company_id !== "") {
      writer.uint32(10).string(message.company_id);
    }
    if (message.phone_number !== "") {
      writer.uint32(18).string(message.phone_number);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ReplaceRequest_DNCRequest {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseReplaceRequest_DNCRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.company_id = reader.string();
          break;
        case 2:
          message.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ReplaceRequest_DNCRequest {
    return {
      company_id: isSet(object.company_id) ? String(object.company_id) : "",
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
    };
  },

  toJSON(message: ReplaceRequest_DNCRequest): unknown {
    const obj: any = {};
    message.company_id !== undefined && (obj.company_id = message.company_id);
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<ReplaceRequest_DNCRequest>, I>>(object: I): ReplaceRequest_DNCRequest {
    const message = createBaseReplaceRequest_DNCRequest();
    message.company_id = object.company_id ?? "";
    message.phone_number = object.phone_number ?? "";
    return message;
  },
};

function createBaseReplaceResponse(): ReplaceResponse {
  return { removed_count: 0 };
}

export const ReplaceResponse = {
  encode(message: ReplaceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.removed_count !== 0) {
      writer.uint32(8).uint32(message.removed_count);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): ReplaceResponse {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseReplaceResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.removed_count = reader.uint32();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): ReplaceResponse {
    return { removed_count: isSet(object.removed_count) ? Number(object.removed_count) : 0 };
  },

  toJSON(message: ReplaceResponse): unknown {
    const obj: any = {};
    message.removed_count !== undefined && (obj.removed_count = Math.round(message.removed_count));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<ReplaceResponse>, I>>(object: I): ReplaceResponse {
    const message = createBaseReplaceResponse();
    message.removed_count = object.removed_count ?? 0;
    return message;
  },
};

export interface BuyerService {
  isDNC(request: IsDNCRequest): Promise<IsDNCResponse>;
  addDisqualified(request: AddDisqualifiedRequest): Promise<AddDisqualifiedResponse>;
  summary(request: SummaryRequest): Promise<SummaryResponse>;
  append(request: AppendRequest): Promise<AppendResponse>;
  remove(request: RemoveRequest): Promise<RemoveResponse>;
  replace(request: ReplaceRequest): Promise<ReplaceResponse>;
}

export class BuyerServiceClientImpl implements BuyerService {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || "dnc.buyer.v1.BuyerService";
    this.rpc = rpc;
    this.isDNC = this.isDNC.bind(this);
    this.addDisqualified = this.addDisqualified.bind(this);
    this.summary = this.summary.bind(this);
    this.append = this.append.bind(this);
    this.remove = this.remove.bind(this);
    this.replace = this.replace.bind(this);
  }
  isDNC(request: IsDNCRequest): Promise<IsDNCResponse> {
    const data = IsDNCRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "IsDNC", data);
    return promise.then((data) => IsDNCResponse.decode(new _m0.Reader(data)));
  }

  addDisqualified(request: AddDisqualifiedRequest): Promise<AddDisqualifiedResponse> {
    const data = AddDisqualifiedRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "AddDisqualified", data);
    return promise.then((data) => AddDisqualifiedResponse.decode(new _m0.Reader(data)));
  }

  summary(request: SummaryRequest): Promise<SummaryResponse> {
    const data = SummaryRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "Summary", data);
    return promise.then((data) => SummaryResponse.decode(new _m0.Reader(data)));
  }

  append(request: AppendRequest): Promise<AppendResponse> {
    const data = AppendRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "Append", data);
    return promise.then((data) => AppendResponse.decode(new _m0.Reader(data)));
  }

  remove(request: RemoveRequest): Promise<RemoveResponse> {
    const data = RemoveRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "Remove", data);
    return promise.then((data) => RemoveResponse.decode(new _m0.Reader(data)));
  }

  replace(request: ReplaceRequest): Promise<ReplaceResponse> {
    const data = ReplaceRequest.encode(request).finish();
    const promise = this.rpc.request(this.service, "Replace", data);
    return promise.then((data) => ReplaceResponse.decode(new _m0.Reader(data)));
  }
}

export type BuyerServiceDefinition = typeof BuyerServiceDefinition;
export const BuyerServiceDefinition = {
  name: "BuyerService",
  fullName: "dnc.buyer.v1.BuyerService",
  methods: {
    isDNC: {
      name: "IsDNC",
      requestType: IsDNCRequest,
      requestStream: false,
      responseType: IsDNCResponse,
      responseStream: false,
      options: {},
    },
    addDisqualified: {
      name: "AddDisqualified",
      requestType: AddDisqualifiedRequest,
      requestStream: false,
      responseType: AddDisqualifiedResponse,
      responseStream: false,
      options: {},
    },
    summary: {
      name: "Summary",
      requestType: SummaryRequest,
      requestStream: false,
      responseType: SummaryResponse,
      responseStream: false,
      options: {},
    },
    append: {
      name: "Append",
      requestType: AppendRequest,
      requestStream: false,
      responseType: AppendResponse,
      responseStream: false,
      options: {},
    },
    remove: {
      name: "Remove",
      requestType: RemoveRequest,
      requestStream: false,
      responseType: RemoveResponse,
      responseStream: false,
      options: {},
    },
    replace: {
      name: "Replace",
      requestType: ReplaceRequest,
      requestStream: false,
      responseType: ReplaceResponse,
      responseStream: false,
      options: {},
    },
  },
} as const;

interface Rpc {
  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin ? T
  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

type KeysOfUnion<T> = T extends T ? keyof T : never;
export type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

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

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

function fromJsonTimestamp(o: any): Date {
  if (o instanceof Date) {
    return o;
  } else if (typeof o === "string") {
    return new Date(o);
  } else {
    return fromTimestamp(Timestamp.fromJSON(o));
  }
}

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