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

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

export interface IsDNCRequest {
  phone_number: string;
}

export interface IsDNCResponse {
  dnc: boolean;
}

export interface AddDisqualifiedRequest {
  phone_number: string;
  source_code: string;
  state: State;
  vertical_id: Vertical;
}

export interface AddDisqualifiedResponse {
}

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

export interface SummaryRequest_SummaryParams {
  start: Date | undefined;
  end: Date | undefined;
  verticals?: SummaryRequest_SummaryParams_Verticals | undefined;
  source_codes?: SummaryRequest_SummaryParams_SourceCodes | undefined;
  states?: SummaryRequest_SummaryParams_States | undefined;
}

export interface SummaryRequest_SummaryParams_Verticals {
  values: Vertical[];
}

export interface SummaryRequest_SummaryParams_States {
  values: State[];
}

export interface SummaryRequest_SummaryParams_SourceCodes {
  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;
  source_code?: string | undefined;
  state?: State | undefined;
  vertical_id?: Vertical | undefined;
}

export interface AppendRequest {
  dncs: AppendRequest_DNCRequest[];
}

export interface AppendRequest_DNCRequest {
  phone_number: string;
  source_code?: string | undefined;
  state?: State | undefined;
  vertical_id?: Vertical | undefined;
}

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

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

export const IsDNCRequest = {
  encode(message: IsDNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.phone_number !== "") {
      writer.uint32(10).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.phone_number = reader.string();
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

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

  toJSON(message: IsDNCRequest): unknown {
    const obj: any = {};
    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.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 { phone_number: "", source_code: "", state: 0, vertical_id: 0 };
}

export const AddDisqualifiedRequest = {
  encode(message: AddDisqualifiedRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.phone_number !== "") {
      writer.uint32(10).string(message.phone_number);
    }
    if (message.source_code !== "") {
      writer.uint32(18).string(message.source_code);
    }
    if (message.state !== 0) {
      writer.uint32(24).int32(message.state);
    }
    if (message.vertical_id !== 0) {
      writer.uint32(32).int32(message.vertical_id);
    }
    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.phone_number = reader.string();
          break;
        case 2:
          message.source_code = reader.string();
          break;
        case 3:
          message.state = reader.int32() as any;
          break;
        case 4:
          message.vertical_id = reader.int32() as any;
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AddDisqualifiedRequest {
    return {
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
      source_code: isSet(object.source_code) ? String(object.source_code) : "",
      state: isSet(object.state) ? stateFromJSON(object.state) : 0,
      vertical_id: isSet(object.vertical_id) ? verticalFromJSON(object.vertical_id) : 0,
    };
  },

  toJSON(message: AddDisqualifiedRequest): unknown {
    const obj: any = {};
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    message.source_code !== undefined && (obj.source_code = message.source_code);
    message.state !== undefined && (obj.state = stateToJSON(message.state));
    message.vertical_id !== undefined && (obj.vertical_id = verticalToJSON(message.vertical_id));
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AddDisqualifiedRequest>, I>>(object: I): AddDisqualifiedRequest {
    const message = createBaseAddDisqualifiedRequest();
    message.phone_number = object.phone_number ?? "";
    message.source_code = object.source_code ?? "";
    message.state = object.state ?? 0;
    message.vertical_id = object.vertical_id ?? 0;
    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, verticals: undefined, source_codes: undefined, states: 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.verticals !== undefined) {
      SummaryRequest_SummaryParams_Verticals.encode(message.verticals, writer.uint32(26).fork()).ldelim();
    }
    if (message.source_codes !== undefined) {
      SummaryRequest_SummaryParams_SourceCodes.encode(message.source_codes, writer.uint32(34).fork()).ldelim();
    }
    if (message.states !== undefined) {
      SummaryRequest_SummaryParams_States.encode(message.states, writer.uint32(42).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.verticals = SummaryRequest_SummaryParams_Verticals.decode(reader, reader.uint32());
          break;
        case 4:
          message.source_codes = SummaryRequest_SummaryParams_SourceCodes.decode(reader, reader.uint32());
          break;
        case 5:
          message.states = SummaryRequest_SummaryParams_States.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,
      verticals: isSet(object.verticals)
        ? SummaryRequest_SummaryParams_Verticals.fromJSON(object.verticals)
        : undefined,
      source_codes: isSet(object.source_codes)
        ? SummaryRequest_SummaryParams_SourceCodes.fromJSON(object.source_codes)
        : undefined,
      states: isSet(object.states) ? SummaryRequest_SummaryParams_States.fromJSON(object.states) : 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.verticals !== undefined &&
      (obj.verticals = message.verticals
        ? SummaryRequest_SummaryParams_Verticals.toJSON(message.verticals)
        : undefined);
    message.source_codes !== undefined && (obj.source_codes = message.source_codes
      ? SummaryRequest_SummaryParams_SourceCodes.toJSON(message.source_codes)
      : undefined);
    message.states !== undefined &&
      (obj.states = message.states ? SummaryRequest_SummaryParams_States.toJSON(message.states) : 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.verticals = (object.verticals !== undefined && object.verticals !== null)
      ? SummaryRequest_SummaryParams_Verticals.fromPartial(object.verticals)
      : undefined;
    message.source_codes = (object.source_codes !== undefined && object.source_codes !== null)
      ? SummaryRequest_SummaryParams_SourceCodes.fromPartial(object.source_codes)
      : undefined;
    message.states = (object.states !== undefined && object.states !== null)
      ? SummaryRequest_SummaryParams_States.fromPartial(object.states)
      : undefined;
    return message;
  },
};

function createBaseSummaryRequest_SummaryParams_Verticals(): SummaryRequest_SummaryParams_Verticals {
  return { values: [] };
}

export const SummaryRequest_SummaryParams_Verticals = {
  encode(message: SummaryRequest_SummaryParams_Verticals, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    writer.uint32(10).fork();
    for (const v of message.values) {
      writer.int32(v);
    }
    writer.ldelim();
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryRequest_SummaryParams_Verticals {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest_SummaryParams_Verticals();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if ((tag & 7) === 2) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.values.push(reader.int32() as any);
            }
          } else {
            message.values.push(reader.int32() as any);
          }
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

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

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

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

function createBaseSummaryRequest_SummaryParams_States(): SummaryRequest_SummaryParams_States {
  return { values: [] };
}

export const SummaryRequest_SummaryParams_States = {
  encode(message: SummaryRequest_SummaryParams_States, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    writer.uint32(10).fork();
    for (const v of message.values) {
      writer.int32(v);
    }
    writer.ldelim();
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): SummaryRequest_SummaryParams_States {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest_SummaryParams_States();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if ((tag & 7) === 2) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.values.push(reader.int32() as any);
            }
          } else {
            message.values.push(reader.int32() as any);
          }
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

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

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

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

function createBaseSummaryRequest_SummaryParams_SourceCodes(): SummaryRequest_SummaryParams_SourceCodes {
  return { values: [] };
}

export const SummaryRequest_SummaryParams_SourceCodes = {
  encode(message: SummaryRequest_SummaryParams_SourceCodes, 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_SourceCodes {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseSummaryRequest_SummaryParams_SourceCodes();
    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_SourceCodes {
    return { values: Array.isArray(object?.values) ? object.values.map((e: any) => String(e)) : [] };
  },

  toJSON(message: SummaryRequest_SummaryParams_SourceCodes): 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_SourceCodes>, I>>(
    object: I,
  ): SummaryRequest_SummaryParams_SourceCodes {
    const message = createBaseSummaryRequest_SummaryParams_SourceCodes();
    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,
    source_code: undefined,
    state: undefined,
    vertical_id: undefined,
  };
}

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.source_code !== undefined) {
      writer.uint32(42).string(message.source_code);
    }
    if (message.state !== undefined) {
      writer.uint32(48).int32(message.state);
    }
    if (message.vertical_id !== undefined) {
      writer.uint32(56).int32(message.vertical_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.source_code = reader.string();
          break;
        case 6:
          message.state = reader.int32() as any;
          break;
        case 7:
          message.vertical_id = reader.int32() as any;
          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,
      source_code: isSet(object.source_code) ? String(object.source_code) : undefined,
      state: isSet(object.state) ? stateFromJSON(object.state) : undefined,
      vertical_id: isSet(object.vertical_id) ? verticalFromJSON(object.vertical_id) : undefined,
    };
  },

  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.source_code !== undefined && (obj.source_code = message.source_code);
    message.state !== undefined && (obj.state = message.state !== undefined ? stateToJSON(message.state) : undefined);
    message.vertical_id !== undefined &&
      (obj.vertical_id = message.vertical_id !== undefined ? verticalToJSON(message.vertical_id) : undefined);
    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.source_code = object.source_code ?? undefined;
    message.state = object.state ?? undefined;
    message.vertical_id = object.vertical_id ?? undefined;
    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 { phone_number: "", source_code: undefined, state: undefined, vertical_id: undefined };
}

export const AppendRequest_DNCRequest = {
  encode(message: AppendRequest_DNCRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.phone_number !== "") {
      writer.uint32(10).string(message.phone_number);
    }
    if (message.source_code !== undefined) {
      writer.uint32(18).string(message.source_code);
    }
    if (message.state !== undefined) {
      writer.uint32(24).int32(message.state);
    }
    if (message.vertical_id !== undefined) {
      writer.uint32(32).int32(message.vertical_id);
    }
    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.phone_number = reader.string();
          break;
        case 2:
          message.source_code = reader.string();
          break;
        case 3:
          message.state = reader.int32() as any;
          break;
        case 4:
          message.vertical_id = reader.int32() as any;
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  },

  fromJSON(object: any): AppendRequest_DNCRequest {
    return {
      phone_number: isSet(object.phone_number) ? String(object.phone_number) : "",
      source_code: isSet(object.source_code) ? String(object.source_code) : undefined,
      state: isSet(object.state) ? stateFromJSON(object.state) : undefined,
      vertical_id: isSet(object.vertical_id) ? verticalFromJSON(object.vertical_id) : undefined,
    };
  },

  toJSON(message: AppendRequest_DNCRequest): unknown {
    const obj: any = {};
    message.phone_number !== undefined && (obj.phone_number = message.phone_number);
    message.source_code !== undefined && (obj.source_code = message.source_code);
    message.state !== undefined && (obj.state = message.state !== undefined ? stateToJSON(message.state) : undefined);
    message.vertical_id !== undefined &&
      (obj.vertical_id = message.vertical_id !== undefined ? verticalToJSON(message.vertical_id) : undefined);
    return obj;
  },

  fromPartial<I extends Exact<DeepPartial<AppendRequest_DNCRequest>, I>>(object: I): AppendRequest_DNCRequest {
    const message = createBaseAppendRequest_DNCRequest();
    message.phone_number = object.phone_number ?? "";
    message.source_code = object.source_code ?? undefined;
    message.state = object.state ?? undefined;
    message.vertical_id = object.vertical_id ?? undefined;
    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;
  },
};

export interface GlobalService {
  isDNC(request: IsDNCRequest): Promise<IsDNCResponse>;
  addDisqualified(request: AddDisqualifiedRequest): Promise<AddDisqualifiedResponse>;
  summary(request: SummaryRequest): Promise<SummaryResponse>;
  append(request: AppendRequest): Promise<AppendResponse>;
}

export class GlobalServiceClientImpl implements GlobalService {
  private readonly rpc: Rpc;
  private readonly service: string;
  constructor(rpc: Rpc, opts?: { service?: string }) {
    this.service = opts?.service || "dnc.global.v1.GlobalService";
    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);
  }
  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)));
  }
}

export type GlobalServiceDefinition = typeof GlobalServiceDefinition;
export const GlobalServiceDefinition = {
  name: "GlobalService",
  fullName: "dnc.global.v1.GlobalService",
  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: {},
    },
  },
} 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;
}