// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.11.8
//   protoc               v6.33.1
// source: documents.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { History } from "./projects.js";

export const protobufPackage = "aristech.nlp";

export enum ContentType {
  IMAGE_PNG = 0,
  APPLICATION_MD = 1,
  APPLICATION_TXT = 2,
  APPLICATION_PDF = 3,
  IMAGE_JPEG = 4,
  IMAGE_WEBP = 5,
  APPLICATION_XLSX = 6,
  UNRECOGNIZED = -1,
}

export function contentTypeFromJSON(object: any): ContentType {
  switch (object) {
    case 0:
    case "IMAGE_PNG":
      return ContentType.IMAGE_PNG;
    case 1:
    case "APPLICATION_MD":
      return ContentType.APPLICATION_MD;
    case 2:
    case "APPLICATION_TXT":
      return ContentType.APPLICATION_TXT;
    case 3:
    case "APPLICATION_PDF":
      return ContentType.APPLICATION_PDF;
    case 4:
    case "IMAGE_JPEG":
      return ContentType.IMAGE_JPEG;
    case 5:
    case "IMAGE_WEBP":
      return ContentType.IMAGE_WEBP;
    case 6:
    case "APPLICATION_XLSX":
      return ContentType.APPLICATION_XLSX;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ContentType.UNRECOGNIZED;
  }
}

export function contentTypeToJSON(object: ContentType): string {
  switch (object) {
    case ContentType.IMAGE_PNG:
      return "IMAGE_PNG";
    case ContentType.APPLICATION_MD:
      return "APPLICATION_MD";
    case ContentType.APPLICATION_TXT:
      return "APPLICATION_TXT";
    case ContentType.APPLICATION_PDF:
      return "APPLICATION_PDF";
    case ContentType.IMAGE_JPEG:
      return "IMAGE_JPEG";
    case ContentType.IMAGE_WEBP:
      return "IMAGE_WEBP";
    case ContentType.APPLICATION_XLSX:
      return "APPLICATION_XLSX";
    case ContentType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/** Document with metadata and content */
export interface Document {
  /** Document ID (only for Get/Update/Delete). */
  id: string;
  /** Project this document belongs to. */
  projectId: string;
  /** Document name/title. */
  name: string;
  /** Content type. */
  contentType: ContentType;
  /** Original filename. */
  filename: string;
  /** Optional description. */
  description: string;
  /** Raw document content (bytes) */
  data: Uint8Array;
  /** Read-only fields (returned by server, ignored on Add/Update): */
  history: History | undefined;
  intentIds: string[];
  processingStatus: ProcessingStatus | undefined;
  chunkCount: number;
  fileSize: number;
  contentHash: string;
  contentPreview: string;
}

/** Processing status. */
export interface ProcessingStatus {
  status: ProcessingStatus_Status;
  progress: number;
  errorMessage: string;
  lastUpdated: string;
}

export enum ProcessingStatus_Status {
  PENDING = 0,
  PROCESSING = 1,
  COMPLETED = 2,
  FAILED = 3,
  UNRECOGNIZED = -1,
}

export function processingStatus_StatusFromJSON(object: any): ProcessingStatus_Status {
  switch (object) {
    case 0:
    case "PENDING":
      return ProcessingStatus_Status.PENDING;
    case 1:
    case "PROCESSING":
      return ProcessingStatus_Status.PROCESSING;
    case 2:
    case "COMPLETED":
      return ProcessingStatus_Status.COMPLETED;
    case 3:
    case "FAILED":
      return ProcessingStatus_Status.FAILED;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ProcessingStatus_Status.UNRECOGNIZED;
  }
}

export function processingStatus_StatusToJSON(object: ProcessingStatus_Status): string {
  switch (object) {
    case ProcessingStatus_Status.PENDING:
      return "PENDING";
    case ProcessingStatus_Status.PROCESSING:
      return "PROCESSING";
    case ProcessingStatus_Status.COMPLETED:
      return "COMPLETED";
    case ProcessingStatus_Status.FAILED:
      return "FAILED";
    case ProcessingStatus_Status.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/** Request to add documents. */
export interface AddDocumentsRequest {
  projectId: string;
  creatorId: string;
  /** Documents to add (with data field filled). */
  documents: Document[];
  autoProcess: boolean;
  chunkingStrategy: string;
  /** If true, exclude output messages from vector search (only inputs will be vectorized). */
  excludeOutputsFromSearch: boolean;
}

/** Response from adding documents. */
export interface AddDocumentsResponse {
  results: AddDocumentsResponse_Result[];
  succeeded: number;
  failed: number;
}

export interface AddDocumentsResponse_Result {
  documentId: string;
  contentHash: string;
  processingStatus: ProcessingStatus | undefined;
  error: string;
}

/** Request to get documents. */
export interface GetDocumentsRequest {
  projectId: string;
  /** Filters */
  contentTypeFilter: ContentType;
  statusFilter: ProcessingStatus_Status;
  documentIds: string[];
  /** Pagination */
  limit: number;
  offset: number;
  /** Include data field in response. */
  includeData: boolean;
  /** Set to true when content_type_filter is explicitly set (needed because enum default 0 = IMAGE_PNG). */
  hasContentTypeFilter: boolean;
  /** Set to true when status_filter is explicitly set (needed because enum default 0 = PENDING). */
  hasStatusFilter: boolean;
}

/** Response with documents. */
export interface GetDocumentsResponse {
  documents: Document[];
  totalCount: number;
}

/** Request to process documents into intents. */
export interface ProcessDocumentsRequest {
  projectId: string;
  documentIds: string[];
  chunkingStrategy: string;
  batchSize: number;
  forceReprocess: boolean;
  /** If true, exclude output messages from vector search (only inputs will be vectorized). */
  excludeOutputsFromSearch: boolean;
}

/** Response from processing. */
export interface ProcessDocumentsResponse {
  results: ProcessDocumentsResponse_Result[];
  succeeded: number;
  failed: number;
}

export interface ProcessDocumentsResponse_Result {
  documentId: string;
  intentsCreated: number;
  intentIds: string[];
  processingStatus: ProcessingStatus | undefined;
  error: string;
}

/**
 * Request to update documents.
 * Fill data field only if content should be updated.
 */
export interface UpdateDocumentsRequest {
  projectId: string;
  /** Documents to update (id required, fill other fields to update them). */
  documents: Document[];
  autoReprocess: boolean;
  deleteOldIntents: boolean;
  /** If true, exclude output messages from vector search (only inputs will be vectorized). */
  excludeOutputsFromSearch: boolean;
}

/** Response from update. */
export interface UpdateDocumentsResponse {
  results: UpdateDocumentsResponse_Result[];
  succeeded: number;
  failed: number;
}

export interface UpdateDocumentsResponse_Result {
  documentId: string;
  contentHash: string;
  processingStatus: ProcessingStatus | undefined;
  deletedIntentsCount: number;
  error: string;
  /** Number of new intents created (if auto_reprocess) */
  intentsCreated: number;
  /** IDs of new intents created (if auto_reprocess) */
  intentIds: string[];
}

/** Request to remove documents. */
export interface RemoveDocumentsRequest {
  projectId: string;
  documentIds: string[];
  cascadeDelete: boolean;
}

/** Response from removal. */
export interface RemoveDocumentsResponse {
  results: RemoveDocumentsResponse_Result[];
  succeeded: number;
  failed: number;
}

export interface RemoveDocumentsResponse_Result {
  documentId: string;
  intentsDeleted: number;
  error: string;
}

/** Request to get document status. */
export interface GetDocumentStatusRequest {
  projectId: string;
  documentIds: string[];
}

/** Response with status. */
export interface GetDocumentStatusResponse {
  statuses: GetDocumentStatusResponse_Status[];
}

export interface GetDocumentStatusResponse_Status {
  documentId: string;
  processingStatus: ProcessingStatus | undefined;
  intentsCreated: number;
  intentIds: string[];
}

function createBaseDocument(): Document {
  return {
    id: "",
    projectId: "",
    name: "",
    contentType: 0,
    filename: "",
    description: "",
    data: new Uint8Array(0),
    history: undefined,
    intentIds: [],
    processingStatus: undefined,
    chunkCount: 0,
    fileSize: 0,
    contentHash: "",
    contentPreview: "",
  };
}

export const Document: MessageFns<Document> = {
  encode(message: Document, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.projectId !== "") {
      writer.uint32(18).string(message.projectId);
    }
    if (message.name !== "") {
      writer.uint32(26).string(message.name);
    }
    if (message.contentType !== 0) {
      writer.uint32(32).int32(message.contentType);
    }
    if (message.filename !== "") {
      writer.uint32(42).string(message.filename);
    }
    if (message.description !== "") {
      writer.uint32(50).string(message.description);
    }
    if (message.data.length !== 0) {
      writer.uint32(58).bytes(message.data);
    }
    if (message.history !== undefined) {
      History.encode(message.history, writer.uint32(66).fork()).join();
    }
    for (const v of message.intentIds) {
      writer.uint32(74).string(v!);
    }
    if (message.processingStatus !== undefined) {
      ProcessingStatus.encode(message.processingStatus, writer.uint32(82).fork()).join();
    }
    if (message.chunkCount !== 0) {
      writer.uint32(88).int32(message.chunkCount);
    }
    if (message.fileSize !== 0) {
      writer.uint32(96).int64(message.fileSize);
    }
    if (message.contentHash !== "") {
      writer.uint32(106).string(message.contentHash);
    }
    if (message.contentPreview !== "") {
      writer.uint32(114).string(message.contentPreview);
    }
    return writer;
  },

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

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

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

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

          message.contentType = reader.int32() as any;
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

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

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

          message.data = reader.bytes();
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }

          message.history = History.decode(reader, reader.uint32());
          continue;
        }
        case 9: {
          if (tag !== 74) {
            break;
          }

          message.intentIds.push(reader.string());
          continue;
        }
        case 10: {
          if (tag !== 82) {
            break;
          }

          message.processingStatus = ProcessingStatus.decode(reader, reader.uint32());
          continue;
        }
        case 11: {
          if (tag !== 88) {
            break;
          }

          message.chunkCount = reader.int32();
          continue;
        }
        case 12: {
          if (tag !== 96) {
            break;
          }

          message.fileSize = longToNumber(reader.int64());
          continue;
        }
        case 13: {
          if (tag !== 106) {
            break;
          }

          message.contentHash = reader.string();
          continue;
        }
        case 14: {
          if (tag !== 114) {
            break;
          }

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

  fromJSON(object: any): Document {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      name: isSet(object.name) ? globalThis.String(object.name) : "",
      contentType: isSet(object.contentType)
        ? contentTypeFromJSON(object.contentType)
        : isSet(object.content_type)
        ? contentTypeFromJSON(object.content_type)
        : 0,
      filename: isSet(object.filename) ? globalThis.String(object.filename) : "",
      description: isSet(object.description) ? globalThis.String(object.description) : "",
      data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0),
      history: isSet(object.history) ? History.fromJSON(object.history) : undefined,
      intentIds: globalThis.Array.isArray(object?.intentIds)
        ? object.intentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.intent_ids)
        ? object.intent_ids.map((e: any) => globalThis.String(e))
        : [],
      processingStatus: isSet(object.processingStatus)
        ? ProcessingStatus.fromJSON(object.processingStatus)
        : isSet(object.processing_status)
        ? ProcessingStatus.fromJSON(object.processing_status)
        : undefined,
      chunkCount: isSet(object.chunkCount)
        ? globalThis.Number(object.chunkCount)
        : isSet(object.chunk_count)
        ? globalThis.Number(object.chunk_count)
        : 0,
      fileSize: isSet(object.fileSize)
        ? globalThis.Number(object.fileSize)
        : isSet(object.file_size)
        ? globalThis.Number(object.file_size)
        : 0,
      contentHash: isSet(object.contentHash)
        ? globalThis.String(object.contentHash)
        : isSet(object.content_hash)
        ? globalThis.String(object.content_hash)
        : "",
      contentPreview: isSet(object.contentPreview)
        ? globalThis.String(object.contentPreview)
        : isSet(object.content_preview)
        ? globalThis.String(object.content_preview)
        : "",
    };
  },

  toJSON(message: Document): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    if (message.contentType !== 0) {
      obj.contentType = contentTypeToJSON(message.contentType);
    }
    if (message.filename !== "") {
      obj.filename = message.filename;
    }
    if (message.description !== "") {
      obj.description = message.description;
    }
    if (message.data.length !== 0) {
      obj.data = base64FromBytes(message.data);
    }
    if (message.history !== undefined) {
      obj.history = History.toJSON(message.history);
    }
    if (message.intentIds?.length) {
      obj.intentIds = message.intentIds;
    }
    if (message.processingStatus !== undefined) {
      obj.processingStatus = ProcessingStatus.toJSON(message.processingStatus);
    }
    if (message.chunkCount !== 0) {
      obj.chunkCount = Math.round(message.chunkCount);
    }
    if (message.fileSize !== 0) {
      obj.fileSize = Math.round(message.fileSize);
    }
    if (message.contentHash !== "") {
      obj.contentHash = message.contentHash;
    }
    if (message.contentPreview !== "") {
      obj.contentPreview = message.contentPreview;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Document>, I>>(base?: I): Document {
    return Document.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Document>, I>>(object: I): Document {
    const message = createBaseDocument();
    message.id = object.id ?? "";
    message.projectId = object.projectId ?? "";
    message.name = object.name ?? "";
    message.contentType = object.contentType ?? 0;
    message.filename = object.filename ?? "";
    message.description = object.description ?? "";
    message.data = object.data ?? new Uint8Array(0);
    message.history = (object.history !== undefined && object.history !== null)
      ? History.fromPartial(object.history)
      : undefined;
    message.intentIds = object.intentIds?.map((e) => e) || [];
    message.processingStatus = (object.processingStatus !== undefined && object.processingStatus !== null)
      ? ProcessingStatus.fromPartial(object.processingStatus)
      : undefined;
    message.chunkCount = object.chunkCount ?? 0;
    message.fileSize = object.fileSize ?? 0;
    message.contentHash = object.contentHash ?? "";
    message.contentPreview = object.contentPreview ?? "";
    return message;
  },
};

function createBaseProcessingStatus(): ProcessingStatus {
  return { status: 0, progress: 0, errorMessage: "", lastUpdated: "" };
}

export const ProcessingStatus: MessageFns<ProcessingStatus> = {
  encode(message: ProcessingStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.status !== 0) {
      writer.uint32(8).int32(message.status);
    }
    if (message.progress !== 0) {
      writer.uint32(16).int32(message.progress);
    }
    if (message.errorMessage !== "") {
      writer.uint32(26).string(message.errorMessage);
    }
    if (message.lastUpdated !== "") {
      writer.uint32(34).string(message.lastUpdated);
    }
    return writer;
  },

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

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

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

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

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

  fromJSON(object: any): ProcessingStatus {
    return {
      status: isSet(object.status) ? processingStatus_StatusFromJSON(object.status) : 0,
      progress: isSet(object.progress) ? globalThis.Number(object.progress) : 0,
      errorMessage: isSet(object.errorMessage)
        ? globalThis.String(object.errorMessage)
        : isSet(object.error_message)
        ? globalThis.String(object.error_message)
        : "",
      lastUpdated: isSet(object.lastUpdated)
        ? globalThis.String(object.lastUpdated)
        : isSet(object.last_updated)
        ? globalThis.String(object.last_updated)
        : "",
    };
  },

  toJSON(message: ProcessingStatus): unknown {
    const obj: any = {};
    if (message.status !== 0) {
      obj.status = processingStatus_StatusToJSON(message.status);
    }
    if (message.progress !== 0) {
      obj.progress = Math.round(message.progress);
    }
    if (message.errorMessage !== "") {
      obj.errorMessage = message.errorMessage;
    }
    if (message.lastUpdated !== "") {
      obj.lastUpdated = message.lastUpdated;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ProcessingStatus>, I>>(base?: I): ProcessingStatus {
    return ProcessingStatus.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ProcessingStatus>, I>>(object: I): ProcessingStatus {
    const message = createBaseProcessingStatus();
    message.status = object.status ?? 0;
    message.progress = object.progress ?? 0;
    message.errorMessage = object.errorMessage ?? "";
    message.lastUpdated = object.lastUpdated ?? "";
    return message;
  },
};

function createBaseAddDocumentsRequest(): AddDocumentsRequest {
  return {
    projectId: "",
    creatorId: "",
    documents: [],
    autoProcess: false,
    chunkingStrategy: "",
    excludeOutputsFromSearch: false,
  };
}

export const AddDocumentsRequest: MessageFns<AddDocumentsRequest> = {
  encode(message: AddDocumentsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    if (message.creatorId !== "") {
      writer.uint32(18).string(message.creatorId);
    }
    for (const v of message.documents) {
      Document.encode(v!, writer.uint32(26).fork()).join();
    }
    if (message.autoProcess !== false) {
      writer.uint32(32).bool(message.autoProcess);
    }
    if (message.chunkingStrategy !== "") {
      writer.uint32(42).string(message.chunkingStrategy);
    }
    if (message.excludeOutputsFromSearch !== false) {
      writer.uint32(48).bool(message.excludeOutputsFromSearch);
    }
    return writer;
  },

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

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

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

          message.documents.push(Document.decode(reader, reader.uint32()));
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

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

          message.chunkingStrategy = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 48) {
            break;
          }

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

  fromJSON(object: any): AddDocumentsRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      creatorId: isSet(object.creatorId)
        ? globalThis.String(object.creatorId)
        : isSet(object.creator_id)
        ? globalThis.String(object.creator_id)
        : "",
      documents: globalThis.Array.isArray(object?.documents)
        ? object.documents.map((e: any) => Document.fromJSON(e))
        : [],
      autoProcess: isSet(object.autoProcess)
        ? globalThis.Boolean(object.autoProcess)
        : isSet(object.auto_process)
        ? globalThis.Boolean(object.auto_process)
        : false,
      chunkingStrategy: isSet(object.chunkingStrategy)
        ? globalThis.String(object.chunkingStrategy)
        : isSet(object.chunking_strategy)
        ? globalThis.String(object.chunking_strategy)
        : "",
      excludeOutputsFromSearch: isSet(object.excludeOutputsFromSearch)
        ? globalThis.Boolean(object.excludeOutputsFromSearch)
        : isSet(object.exclude_outputs_from_search)
        ? globalThis.Boolean(object.exclude_outputs_from_search)
        : false,
    };
  },

  toJSON(message: AddDocumentsRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.creatorId !== "") {
      obj.creatorId = message.creatorId;
    }
    if (message.documents?.length) {
      obj.documents = message.documents.map((e) => Document.toJSON(e));
    }
    if (message.autoProcess !== false) {
      obj.autoProcess = message.autoProcess;
    }
    if (message.chunkingStrategy !== "") {
      obj.chunkingStrategy = message.chunkingStrategy;
    }
    if (message.excludeOutputsFromSearch !== false) {
      obj.excludeOutputsFromSearch = message.excludeOutputsFromSearch;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AddDocumentsRequest>, I>>(base?: I): AddDocumentsRequest {
    return AddDocumentsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AddDocumentsRequest>, I>>(object: I): AddDocumentsRequest {
    const message = createBaseAddDocumentsRequest();
    message.projectId = object.projectId ?? "";
    message.creatorId = object.creatorId ?? "";
    message.documents = object.documents?.map((e) => Document.fromPartial(e)) || [];
    message.autoProcess = object.autoProcess ?? false;
    message.chunkingStrategy = object.chunkingStrategy ?? "";
    message.excludeOutputsFromSearch = object.excludeOutputsFromSearch ?? false;
    return message;
  },
};

function createBaseAddDocumentsResponse(): AddDocumentsResponse {
  return { results: [], succeeded: 0, failed: 0 };
}

export const AddDocumentsResponse: MessageFns<AddDocumentsResponse> = {
  encode(message: AddDocumentsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.results) {
      AddDocumentsResponse_Result.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.succeeded !== 0) {
      writer.uint32(16).int32(message.succeeded);
    }
    if (message.failed !== 0) {
      writer.uint32(24).int32(message.failed);
    }
    return writer;
  },

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

          message.results.push(AddDocumentsResponse_Result.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.succeeded = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

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

  fromJSON(object: any): AddDocumentsResponse {
    return {
      results: globalThis.Array.isArray(object?.results)
        ? object.results.map((e: any) => AddDocumentsResponse_Result.fromJSON(e))
        : [],
      succeeded: isSet(object.succeeded) ? globalThis.Number(object.succeeded) : 0,
      failed: isSet(object.failed) ? globalThis.Number(object.failed) : 0,
    };
  },

  toJSON(message: AddDocumentsResponse): unknown {
    const obj: any = {};
    if (message.results?.length) {
      obj.results = message.results.map((e) => AddDocumentsResponse_Result.toJSON(e));
    }
    if (message.succeeded !== 0) {
      obj.succeeded = Math.round(message.succeeded);
    }
    if (message.failed !== 0) {
      obj.failed = Math.round(message.failed);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AddDocumentsResponse>, I>>(base?: I): AddDocumentsResponse {
    return AddDocumentsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AddDocumentsResponse>, I>>(object: I): AddDocumentsResponse {
    const message = createBaseAddDocumentsResponse();
    message.results = object.results?.map((e) => AddDocumentsResponse_Result.fromPartial(e)) || [];
    message.succeeded = object.succeeded ?? 0;
    message.failed = object.failed ?? 0;
    return message;
  },
};

function createBaseAddDocumentsResponse_Result(): AddDocumentsResponse_Result {
  return { documentId: "", contentHash: "", processingStatus: undefined, error: "" };
}

export const AddDocumentsResponse_Result: MessageFns<AddDocumentsResponse_Result> = {
  encode(message: AddDocumentsResponse_Result, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.documentId !== "") {
      writer.uint32(10).string(message.documentId);
    }
    if (message.contentHash !== "") {
      writer.uint32(18).string(message.contentHash);
    }
    if (message.processingStatus !== undefined) {
      ProcessingStatus.encode(message.processingStatus, writer.uint32(26).fork()).join();
    }
    if (message.error !== "") {
      writer.uint32(34).string(message.error);
    }
    return writer;
  },

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

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

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

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

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

  fromJSON(object: any): AddDocumentsResponse_Result {
    return {
      documentId: isSet(object.documentId)
        ? globalThis.String(object.documentId)
        : isSet(object.document_id)
        ? globalThis.String(object.document_id)
        : "",
      contentHash: isSet(object.contentHash)
        ? globalThis.String(object.contentHash)
        : isSet(object.content_hash)
        ? globalThis.String(object.content_hash)
        : "",
      processingStatus: isSet(object.processingStatus)
        ? ProcessingStatus.fromJSON(object.processingStatus)
        : isSet(object.processing_status)
        ? ProcessingStatus.fromJSON(object.processing_status)
        : undefined,
      error: isSet(object.error) ? globalThis.String(object.error) : "",
    };
  },

  toJSON(message: AddDocumentsResponse_Result): unknown {
    const obj: any = {};
    if (message.documentId !== "") {
      obj.documentId = message.documentId;
    }
    if (message.contentHash !== "") {
      obj.contentHash = message.contentHash;
    }
    if (message.processingStatus !== undefined) {
      obj.processingStatus = ProcessingStatus.toJSON(message.processingStatus);
    }
    if (message.error !== "") {
      obj.error = message.error;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AddDocumentsResponse_Result>, I>>(base?: I): AddDocumentsResponse_Result {
    return AddDocumentsResponse_Result.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AddDocumentsResponse_Result>, I>>(object: I): AddDocumentsResponse_Result {
    const message = createBaseAddDocumentsResponse_Result();
    message.documentId = object.documentId ?? "";
    message.contentHash = object.contentHash ?? "";
    message.processingStatus = (object.processingStatus !== undefined && object.processingStatus !== null)
      ? ProcessingStatus.fromPartial(object.processingStatus)
      : undefined;
    message.error = object.error ?? "";
    return message;
  },
};

function createBaseGetDocumentsRequest(): GetDocumentsRequest {
  return {
    projectId: "",
    contentTypeFilter: 0,
    statusFilter: 0,
    documentIds: [],
    limit: 0,
    offset: 0,
    includeData: false,
    hasContentTypeFilter: false,
    hasStatusFilter: false,
  };
}

export const GetDocumentsRequest: MessageFns<GetDocumentsRequest> = {
  encode(message: GetDocumentsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    if (message.contentTypeFilter !== 0) {
      writer.uint32(16).int32(message.contentTypeFilter);
    }
    if (message.statusFilter !== 0) {
      writer.uint32(24).int32(message.statusFilter);
    }
    for (const v of message.documentIds) {
      writer.uint32(34).string(v!);
    }
    if (message.limit !== 0) {
      writer.uint32(40).int32(message.limit);
    }
    if (message.offset !== 0) {
      writer.uint32(48).int32(message.offset);
    }
    if (message.includeData !== false) {
      writer.uint32(56).bool(message.includeData);
    }
    if (message.hasContentTypeFilter !== false) {
      writer.uint32(64).bool(message.hasContentTypeFilter);
    }
    if (message.hasStatusFilter !== false) {
      writer.uint32(72).bool(message.hasStatusFilter);
    }
    return writer;
  },

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

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

          message.contentTypeFilter = reader.int32() as any;
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.statusFilter = reader.int32() as any;
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.documentIds.push(reader.string());
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.limit = reader.int32();
          continue;
        }
        case 6: {
          if (tag !== 48) {
            break;
          }

          message.offset = reader.int32();
          continue;
        }
        case 7: {
          if (tag !== 56) {
            break;
          }

          message.includeData = reader.bool();
          continue;
        }
        case 8: {
          if (tag !== 64) {
            break;
          }

          message.hasContentTypeFilter = reader.bool();
          continue;
        }
        case 9: {
          if (tag !== 72) {
            break;
          }

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

  fromJSON(object: any): GetDocumentsRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      contentTypeFilter: isSet(object.contentTypeFilter)
        ? contentTypeFromJSON(object.contentTypeFilter)
        : isSet(object.content_type_filter)
        ? contentTypeFromJSON(object.content_type_filter)
        : 0,
      statusFilter: isSet(object.statusFilter)
        ? processingStatus_StatusFromJSON(object.statusFilter)
        : isSet(object.status_filter)
        ? processingStatus_StatusFromJSON(object.status_filter)
        : 0,
      documentIds: globalThis.Array.isArray(object?.documentIds)
        ? object.documentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.document_ids)
        ? object.document_ids.map((e: any) => globalThis.String(e))
        : [],
      limit: isSet(object.limit) ? globalThis.Number(object.limit) : 0,
      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
      includeData: isSet(object.includeData)
        ? globalThis.Boolean(object.includeData)
        : isSet(object.include_data)
        ? globalThis.Boolean(object.include_data)
        : false,
      hasContentTypeFilter: isSet(object.hasContentTypeFilter)
        ? globalThis.Boolean(object.hasContentTypeFilter)
        : isSet(object.has_content_type_filter)
        ? globalThis.Boolean(object.has_content_type_filter)
        : false,
      hasStatusFilter: isSet(object.hasStatusFilter)
        ? globalThis.Boolean(object.hasStatusFilter)
        : isSet(object.has_status_filter)
        ? globalThis.Boolean(object.has_status_filter)
        : false,
    };
  },

  toJSON(message: GetDocumentsRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.contentTypeFilter !== 0) {
      obj.contentTypeFilter = contentTypeToJSON(message.contentTypeFilter);
    }
    if (message.statusFilter !== 0) {
      obj.statusFilter = processingStatus_StatusToJSON(message.statusFilter);
    }
    if (message.documentIds?.length) {
      obj.documentIds = message.documentIds;
    }
    if (message.limit !== 0) {
      obj.limit = Math.round(message.limit);
    }
    if (message.offset !== 0) {
      obj.offset = Math.round(message.offset);
    }
    if (message.includeData !== false) {
      obj.includeData = message.includeData;
    }
    if (message.hasContentTypeFilter !== false) {
      obj.hasContentTypeFilter = message.hasContentTypeFilter;
    }
    if (message.hasStatusFilter !== false) {
      obj.hasStatusFilter = message.hasStatusFilter;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetDocumentsRequest>, I>>(base?: I): GetDocumentsRequest {
    return GetDocumentsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetDocumentsRequest>, I>>(object: I): GetDocumentsRequest {
    const message = createBaseGetDocumentsRequest();
    message.projectId = object.projectId ?? "";
    message.contentTypeFilter = object.contentTypeFilter ?? 0;
    message.statusFilter = object.statusFilter ?? 0;
    message.documentIds = object.documentIds?.map((e) => e) || [];
    message.limit = object.limit ?? 0;
    message.offset = object.offset ?? 0;
    message.includeData = object.includeData ?? false;
    message.hasContentTypeFilter = object.hasContentTypeFilter ?? false;
    message.hasStatusFilter = object.hasStatusFilter ?? false;
    return message;
  },
};

function createBaseGetDocumentsResponse(): GetDocumentsResponse {
  return { documents: [], totalCount: 0 };
}

export const GetDocumentsResponse: MessageFns<GetDocumentsResponse> = {
  encode(message: GetDocumentsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.documents) {
      Document.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.totalCount !== 0) {
      writer.uint32(16).int32(message.totalCount);
    }
    return writer;
  },

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

          message.documents.push(Document.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

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

  fromJSON(object: any): GetDocumentsResponse {
    return {
      documents: globalThis.Array.isArray(object?.documents)
        ? object.documents.map((e: any) => Document.fromJSON(e))
        : [],
      totalCount: isSet(object.totalCount)
        ? globalThis.Number(object.totalCount)
        : isSet(object.total_count)
        ? globalThis.Number(object.total_count)
        : 0,
    };
  },

  toJSON(message: GetDocumentsResponse): unknown {
    const obj: any = {};
    if (message.documents?.length) {
      obj.documents = message.documents.map((e) => Document.toJSON(e));
    }
    if (message.totalCount !== 0) {
      obj.totalCount = Math.round(message.totalCount);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetDocumentsResponse>, I>>(base?: I): GetDocumentsResponse {
    return GetDocumentsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetDocumentsResponse>, I>>(object: I): GetDocumentsResponse {
    const message = createBaseGetDocumentsResponse();
    message.documents = object.documents?.map((e) => Document.fromPartial(e)) || [];
    message.totalCount = object.totalCount ?? 0;
    return message;
  },
};

function createBaseProcessDocumentsRequest(): ProcessDocumentsRequest {
  return {
    projectId: "",
    documentIds: [],
    chunkingStrategy: "",
    batchSize: 0,
    forceReprocess: false,
    excludeOutputsFromSearch: false,
  };
}

export const ProcessDocumentsRequest: MessageFns<ProcessDocumentsRequest> = {
  encode(message: ProcessDocumentsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    for (const v of message.documentIds) {
      writer.uint32(18).string(v!);
    }
    if (message.chunkingStrategy !== "") {
      writer.uint32(26).string(message.chunkingStrategy);
    }
    if (message.batchSize !== 0) {
      writer.uint32(32).int32(message.batchSize);
    }
    if (message.forceReprocess !== false) {
      writer.uint32(40).bool(message.forceReprocess);
    }
    if (message.excludeOutputsFromSearch !== false) {
      writer.uint32(48).bool(message.excludeOutputsFromSearch);
    }
    return writer;
  },

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

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

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

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

          message.batchSize = reader.int32();
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

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

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

  fromJSON(object: any): ProcessDocumentsRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      documentIds: globalThis.Array.isArray(object?.documentIds)
        ? object.documentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.document_ids)
        ? object.document_ids.map((e: any) => globalThis.String(e))
        : [],
      chunkingStrategy: isSet(object.chunkingStrategy)
        ? globalThis.String(object.chunkingStrategy)
        : isSet(object.chunking_strategy)
        ? globalThis.String(object.chunking_strategy)
        : "",
      batchSize: isSet(object.batchSize)
        ? globalThis.Number(object.batchSize)
        : isSet(object.batch_size)
        ? globalThis.Number(object.batch_size)
        : 0,
      forceReprocess: isSet(object.forceReprocess)
        ? globalThis.Boolean(object.forceReprocess)
        : isSet(object.force_reprocess)
        ? globalThis.Boolean(object.force_reprocess)
        : false,
      excludeOutputsFromSearch: isSet(object.excludeOutputsFromSearch)
        ? globalThis.Boolean(object.excludeOutputsFromSearch)
        : isSet(object.exclude_outputs_from_search)
        ? globalThis.Boolean(object.exclude_outputs_from_search)
        : false,
    };
  },

  toJSON(message: ProcessDocumentsRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.documentIds?.length) {
      obj.documentIds = message.documentIds;
    }
    if (message.chunkingStrategy !== "") {
      obj.chunkingStrategy = message.chunkingStrategy;
    }
    if (message.batchSize !== 0) {
      obj.batchSize = Math.round(message.batchSize);
    }
    if (message.forceReprocess !== false) {
      obj.forceReprocess = message.forceReprocess;
    }
    if (message.excludeOutputsFromSearch !== false) {
      obj.excludeOutputsFromSearch = message.excludeOutputsFromSearch;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ProcessDocumentsRequest>, I>>(base?: I): ProcessDocumentsRequest {
    return ProcessDocumentsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ProcessDocumentsRequest>, I>>(object: I): ProcessDocumentsRequest {
    const message = createBaseProcessDocumentsRequest();
    message.projectId = object.projectId ?? "";
    message.documentIds = object.documentIds?.map((e) => e) || [];
    message.chunkingStrategy = object.chunkingStrategy ?? "";
    message.batchSize = object.batchSize ?? 0;
    message.forceReprocess = object.forceReprocess ?? false;
    message.excludeOutputsFromSearch = object.excludeOutputsFromSearch ?? false;
    return message;
  },
};

function createBaseProcessDocumentsResponse(): ProcessDocumentsResponse {
  return { results: [], succeeded: 0, failed: 0 };
}

export const ProcessDocumentsResponse: MessageFns<ProcessDocumentsResponse> = {
  encode(message: ProcessDocumentsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.results) {
      ProcessDocumentsResponse_Result.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.succeeded !== 0) {
      writer.uint32(16).int32(message.succeeded);
    }
    if (message.failed !== 0) {
      writer.uint32(24).int32(message.failed);
    }
    return writer;
  },

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

          message.results.push(ProcessDocumentsResponse_Result.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.succeeded = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

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

  fromJSON(object: any): ProcessDocumentsResponse {
    return {
      results: globalThis.Array.isArray(object?.results)
        ? object.results.map((e: any) => ProcessDocumentsResponse_Result.fromJSON(e))
        : [],
      succeeded: isSet(object.succeeded) ? globalThis.Number(object.succeeded) : 0,
      failed: isSet(object.failed) ? globalThis.Number(object.failed) : 0,
    };
  },

  toJSON(message: ProcessDocumentsResponse): unknown {
    const obj: any = {};
    if (message.results?.length) {
      obj.results = message.results.map((e) => ProcessDocumentsResponse_Result.toJSON(e));
    }
    if (message.succeeded !== 0) {
      obj.succeeded = Math.round(message.succeeded);
    }
    if (message.failed !== 0) {
      obj.failed = Math.round(message.failed);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ProcessDocumentsResponse>, I>>(base?: I): ProcessDocumentsResponse {
    return ProcessDocumentsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ProcessDocumentsResponse>, I>>(object: I): ProcessDocumentsResponse {
    const message = createBaseProcessDocumentsResponse();
    message.results = object.results?.map((e) => ProcessDocumentsResponse_Result.fromPartial(e)) || [];
    message.succeeded = object.succeeded ?? 0;
    message.failed = object.failed ?? 0;
    return message;
  },
};

function createBaseProcessDocumentsResponse_Result(): ProcessDocumentsResponse_Result {
  return { documentId: "", intentsCreated: 0, intentIds: [], processingStatus: undefined, error: "" };
}

export const ProcessDocumentsResponse_Result: MessageFns<ProcessDocumentsResponse_Result> = {
  encode(message: ProcessDocumentsResponse_Result, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.documentId !== "") {
      writer.uint32(10).string(message.documentId);
    }
    if (message.intentsCreated !== 0) {
      writer.uint32(16).int32(message.intentsCreated);
    }
    for (const v of message.intentIds) {
      writer.uint32(26).string(v!);
    }
    if (message.processingStatus !== undefined) {
      ProcessingStatus.encode(message.processingStatus, writer.uint32(34).fork()).join();
    }
    if (message.error !== "") {
      writer.uint32(42).string(message.error);
    }
    return writer;
  },

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

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

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

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

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

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

  fromJSON(object: any): ProcessDocumentsResponse_Result {
    return {
      documentId: isSet(object.documentId)
        ? globalThis.String(object.documentId)
        : isSet(object.document_id)
        ? globalThis.String(object.document_id)
        : "",
      intentsCreated: isSet(object.intentsCreated)
        ? globalThis.Number(object.intentsCreated)
        : isSet(object.intents_created)
        ? globalThis.Number(object.intents_created)
        : 0,
      intentIds: globalThis.Array.isArray(object?.intentIds)
        ? object.intentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.intent_ids)
        ? object.intent_ids.map((e: any) => globalThis.String(e))
        : [],
      processingStatus: isSet(object.processingStatus)
        ? ProcessingStatus.fromJSON(object.processingStatus)
        : isSet(object.processing_status)
        ? ProcessingStatus.fromJSON(object.processing_status)
        : undefined,
      error: isSet(object.error) ? globalThis.String(object.error) : "",
    };
  },

  toJSON(message: ProcessDocumentsResponse_Result): unknown {
    const obj: any = {};
    if (message.documentId !== "") {
      obj.documentId = message.documentId;
    }
    if (message.intentsCreated !== 0) {
      obj.intentsCreated = Math.round(message.intentsCreated);
    }
    if (message.intentIds?.length) {
      obj.intentIds = message.intentIds;
    }
    if (message.processingStatus !== undefined) {
      obj.processingStatus = ProcessingStatus.toJSON(message.processingStatus);
    }
    if (message.error !== "") {
      obj.error = message.error;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ProcessDocumentsResponse_Result>, I>>(base?: I): ProcessDocumentsResponse_Result {
    return ProcessDocumentsResponse_Result.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ProcessDocumentsResponse_Result>, I>>(
    object: I,
  ): ProcessDocumentsResponse_Result {
    const message = createBaseProcessDocumentsResponse_Result();
    message.documentId = object.documentId ?? "";
    message.intentsCreated = object.intentsCreated ?? 0;
    message.intentIds = object.intentIds?.map((e) => e) || [];
    message.processingStatus = (object.processingStatus !== undefined && object.processingStatus !== null)
      ? ProcessingStatus.fromPartial(object.processingStatus)
      : undefined;
    message.error = object.error ?? "";
    return message;
  },
};

function createBaseUpdateDocumentsRequest(): UpdateDocumentsRequest {
  return {
    projectId: "",
    documents: [],
    autoReprocess: false,
    deleteOldIntents: false,
    excludeOutputsFromSearch: false,
  };
}

export const UpdateDocumentsRequest: MessageFns<UpdateDocumentsRequest> = {
  encode(message: UpdateDocumentsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    for (const v of message.documents) {
      Document.encode(v!, writer.uint32(18).fork()).join();
    }
    if (message.autoReprocess !== false) {
      writer.uint32(24).bool(message.autoReprocess);
    }
    if (message.deleteOldIntents !== false) {
      writer.uint32(32).bool(message.deleteOldIntents);
    }
    if (message.excludeOutputsFromSearch !== false) {
      writer.uint32(40).bool(message.excludeOutputsFromSearch);
    }
    return writer;
  },

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

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

          message.documents.push(Document.decode(reader, reader.uint32()));
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.autoReprocess = reader.bool();
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.deleteOldIntents = reader.bool();
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

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

  fromJSON(object: any): UpdateDocumentsRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      documents: globalThis.Array.isArray(object?.documents)
        ? object.documents.map((e: any) => Document.fromJSON(e))
        : [],
      autoReprocess: isSet(object.autoReprocess)
        ? globalThis.Boolean(object.autoReprocess)
        : isSet(object.auto_reprocess)
        ? globalThis.Boolean(object.auto_reprocess)
        : false,
      deleteOldIntents: isSet(object.deleteOldIntents)
        ? globalThis.Boolean(object.deleteOldIntents)
        : isSet(object.delete_old_intents)
        ? globalThis.Boolean(object.delete_old_intents)
        : false,
      excludeOutputsFromSearch: isSet(object.excludeOutputsFromSearch)
        ? globalThis.Boolean(object.excludeOutputsFromSearch)
        : isSet(object.exclude_outputs_from_search)
        ? globalThis.Boolean(object.exclude_outputs_from_search)
        : false,
    };
  },

  toJSON(message: UpdateDocumentsRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.documents?.length) {
      obj.documents = message.documents.map((e) => Document.toJSON(e));
    }
    if (message.autoReprocess !== false) {
      obj.autoReprocess = message.autoReprocess;
    }
    if (message.deleteOldIntents !== false) {
      obj.deleteOldIntents = message.deleteOldIntents;
    }
    if (message.excludeOutputsFromSearch !== false) {
      obj.excludeOutputsFromSearch = message.excludeOutputsFromSearch;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<UpdateDocumentsRequest>, I>>(base?: I): UpdateDocumentsRequest {
    return UpdateDocumentsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<UpdateDocumentsRequest>, I>>(object: I): UpdateDocumentsRequest {
    const message = createBaseUpdateDocumentsRequest();
    message.projectId = object.projectId ?? "";
    message.documents = object.documents?.map((e) => Document.fromPartial(e)) || [];
    message.autoReprocess = object.autoReprocess ?? false;
    message.deleteOldIntents = object.deleteOldIntents ?? false;
    message.excludeOutputsFromSearch = object.excludeOutputsFromSearch ?? false;
    return message;
  },
};

function createBaseUpdateDocumentsResponse(): UpdateDocumentsResponse {
  return { results: [], succeeded: 0, failed: 0 };
}

export const UpdateDocumentsResponse: MessageFns<UpdateDocumentsResponse> = {
  encode(message: UpdateDocumentsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.results) {
      UpdateDocumentsResponse_Result.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.succeeded !== 0) {
      writer.uint32(16).int32(message.succeeded);
    }
    if (message.failed !== 0) {
      writer.uint32(24).int32(message.failed);
    }
    return writer;
  },

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

          message.results.push(UpdateDocumentsResponse_Result.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.succeeded = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

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

  fromJSON(object: any): UpdateDocumentsResponse {
    return {
      results: globalThis.Array.isArray(object?.results)
        ? object.results.map((e: any) => UpdateDocumentsResponse_Result.fromJSON(e))
        : [],
      succeeded: isSet(object.succeeded) ? globalThis.Number(object.succeeded) : 0,
      failed: isSet(object.failed) ? globalThis.Number(object.failed) : 0,
    };
  },

  toJSON(message: UpdateDocumentsResponse): unknown {
    const obj: any = {};
    if (message.results?.length) {
      obj.results = message.results.map((e) => UpdateDocumentsResponse_Result.toJSON(e));
    }
    if (message.succeeded !== 0) {
      obj.succeeded = Math.round(message.succeeded);
    }
    if (message.failed !== 0) {
      obj.failed = Math.round(message.failed);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<UpdateDocumentsResponse>, I>>(base?: I): UpdateDocumentsResponse {
    return UpdateDocumentsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<UpdateDocumentsResponse>, I>>(object: I): UpdateDocumentsResponse {
    const message = createBaseUpdateDocumentsResponse();
    message.results = object.results?.map((e) => UpdateDocumentsResponse_Result.fromPartial(e)) || [];
    message.succeeded = object.succeeded ?? 0;
    message.failed = object.failed ?? 0;
    return message;
  },
};

function createBaseUpdateDocumentsResponse_Result(): UpdateDocumentsResponse_Result {
  return {
    documentId: "",
    contentHash: "",
    processingStatus: undefined,
    deletedIntentsCount: 0,
    error: "",
    intentsCreated: 0,
    intentIds: [],
  };
}

export const UpdateDocumentsResponse_Result: MessageFns<UpdateDocumentsResponse_Result> = {
  encode(message: UpdateDocumentsResponse_Result, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.documentId !== "") {
      writer.uint32(10).string(message.documentId);
    }
    if (message.contentHash !== "") {
      writer.uint32(18).string(message.contentHash);
    }
    if (message.processingStatus !== undefined) {
      ProcessingStatus.encode(message.processingStatus, writer.uint32(26).fork()).join();
    }
    if (message.deletedIntentsCount !== 0) {
      writer.uint32(32).int32(message.deletedIntentsCount);
    }
    if (message.error !== "") {
      writer.uint32(42).string(message.error);
    }
    if (message.intentsCreated !== 0) {
      writer.uint32(48).int32(message.intentsCreated);
    }
    for (const v of message.intentIds) {
      writer.uint32(58).string(v!);
    }
    return writer;
  },

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

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

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

          message.processingStatus = ProcessingStatus.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

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

          message.error = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 48) {
            break;
          }

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

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

  fromJSON(object: any): UpdateDocumentsResponse_Result {
    return {
      documentId: isSet(object.documentId)
        ? globalThis.String(object.documentId)
        : isSet(object.document_id)
        ? globalThis.String(object.document_id)
        : "",
      contentHash: isSet(object.contentHash)
        ? globalThis.String(object.contentHash)
        : isSet(object.content_hash)
        ? globalThis.String(object.content_hash)
        : "",
      processingStatus: isSet(object.processingStatus)
        ? ProcessingStatus.fromJSON(object.processingStatus)
        : isSet(object.processing_status)
        ? ProcessingStatus.fromJSON(object.processing_status)
        : undefined,
      deletedIntentsCount: isSet(object.deletedIntentsCount)
        ? globalThis.Number(object.deletedIntentsCount)
        : isSet(object.deleted_intents_count)
        ? globalThis.Number(object.deleted_intents_count)
        : 0,
      error: isSet(object.error) ? globalThis.String(object.error) : "",
      intentsCreated: isSet(object.intentsCreated)
        ? globalThis.Number(object.intentsCreated)
        : isSet(object.intents_created)
        ? globalThis.Number(object.intents_created)
        : 0,
      intentIds: globalThis.Array.isArray(object?.intentIds)
        ? object.intentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.intent_ids)
        ? object.intent_ids.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: UpdateDocumentsResponse_Result): unknown {
    const obj: any = {};
    if (message.documentId !== "") {
      obj.documentId = message.documentId;
    }
    if (message.contentHash !== "") {
      obj.contentHash = message.contentHash;
    }
    if (message.processingStatus !== undefined) {
      obj.processingStatus = ProcessingStatus.toJSON(message.processingStatus);
    }
    if (message.deletedIntentsCount !== 0) {
      obj.deletedIntentsCount = Math.round(message.deletedIntentsCount);
    }
    if (message.error !== "") {
      obj.error = message.error;
    }
    if (message.intentsCreated !== 0) {
      obj.intentsCreated = Math.round(message.intentsCreated);
    }
    if (message.intentIds?.length) {
      obj.intentIds = message.intentIds;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<UpdateDocumentsResponse_Result>, I>>(base?: I): UpdateDocumentsResponse_Result {
    return UpdateDocumentsResponse_Result.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<UpdateDocumentsResponse_Result>, I>>(
    object: I,
  ): UpdateDocumentsResponse_Result {
    const message = createBaseUpdateDocumentsResponse_Result();
    message.documentId = object.documentId ?? "";
    message.contentHash = object.contentHash ?? "";
    message.processingStatus = (object.processingStatus !== undefined && object.processingStatus !== null)
      ? ProcessingStatus.fromPartial(object.processingStatus)
      : undefined;
    message.deletedIntentsCount = object.deletedIntentsCount ?? 0;
    message.error = object.error ?? "";
    message.intentsCreated = object.intentsCreated ?? 0;
    message.intentIds = object.intentIds?.map((e) => e) || [];
    return message;
  },
};

function createBaseRemoveDocumentsRequest(): RemoveDocumentsRequest {
  return { projectId: "", documentIds: [], cascadeDelete: false };
}

export const RemoveDocumentsRequest: MessageFns<RemoveDocumentsRequest> = {
  encode(message: RemoveDocumentsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    for (const v of message.documentIds) {
      writer.uint32(18).string(v!);
    }
    if (message.cascadeDelete !== false) {
      writer.uint32(24).bool(message.cascadeDelete);
    }
    return writer;
  },

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

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

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

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

  fromJSON(object: any): RemoveDocumentsRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      documentIds: globalThis.Array.isArray(object?.documentIds)
        ? object.documentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.document_ids)
        ? object.document_ids.map((e: any) => globalThis.String(e))
        : [],
      cascadeDelete: isSet(object.cascadeDelete)
        ? globalThis.Boolean(object.cascadeDelete)
        : isSet(object.cascade_delete)
        ? globalThis.Boolean(object.cascade_delete)
        : false,
    };
  },

  toJSON(message: RemoveDocumentsRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.documentIds?.length) {
      obj.documentIds = message.documentIds;
    }
    if (message.cascadeDelete !== false) {
      obj.cascadeDelete = message.cascadeDelete;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RemoveDocumentsRequest>, I>>(base?: I): RemoveDocumentsRequest {
    return RemoveDocumentsRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RemoveDocumentsRequest>, I>>(object: I): RemoveDocumentsRequest {
    const message = createBaseRemoveDocumentsRequest();
    message.projectId = object.projectId ?? "";
    message.documentIds = object.documentIds?.map((e) => e) || [];
    message.cascadeDelete = object.cascadeDelete ?? false;
    return message;
  },
};

function createBaseRemoveDocumentsResponse(): RemoveDocumentsResponse {
  return { results: [], succeeded: 0, failed: 0 };
}

export const RemoveDocumentsResponse: MessageFns<RemoveDocumentsResponse> = {
  encode(message: RemoveDocumentsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.results) {
      RemoveDocumentsResponse_Result.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.succeeded !== 0) {
      writer.uint32(16).int32(message.succeeded);
    }
    if (message.failed !== 0) {
      writer.uint32(24).int32(message.failed);
    }
    return writer;
  },

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

          message.results.push(RemoveDocumentsResponse_Result.decode(reader, reader.uint32()));
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.succeeded = reader.int32();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

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

  fromJSON(object: any): RemoveDocumentsResponse {
    return {
      results: globalThis.Array.isArray(object?.results)
        ? object.results.map((e: any) => RemoveDocumentsResponse_Result.fromJSON(e))
        : [],
      succeeded: isSet(object.succeeded) ? globalThis.Number(object.succeeded) : 0,
      failed: isSet(object.failed) ? globalThis.Number(object.failed) : 0,
    };
  },

  toJSON(message: RemoveDocumentsResponse): unknown {
    const obj: any = {};
    if (message.results?.length) {
      obj.results = message.results.map((e) => RemoveDocumentsResponse_Result.toJSON(e));
    }
    if (message.succeeded !== 0) {
      obj.succeeded = Math.round(message.succeeded);
    }
    if (message.failed !== 0) {
      obj.failed = Math.round(message.failed);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RemoveDocumentsResponse>, I>>(base?: I): RemoveDocumentsResponse {
    return RemoveDocumentsResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RemoveDocumentsResponse>, I>>(object: I): RemoveDocumentsResponse {
    const message = createBaseRemoveDocumentsResponse();
    message.results = object.results?.map((e) => RemoveDocumentsResponse_Result.fromPartial(e)) || [];
    message.succeeded = object.succeeded ?? 0;
    message.failed = object.failed ?? 0;
    return message;
  },
};

function createBaseRemoveDocumentsResponse_Result(): RemoveDocumentsResponse_Result {
  return { documentId: "", intentsDeleted: 0, error: "" };
}

export const RemoveDocumentsResponse_Result: MessageFns<RemoveDocumentsResponse_Result> = {
  encode(message: RemoveDocumentsResponse_Result, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.documentId !== "") {
      writer.uint32(10).string(message.documentId);
    }
    if (message.intentsDeleted !== 0) {
      writer.uint32(16).int32(message.intentsDeleted);
    }
    if (message.error !== "") {
      writer.uint32(26).string(message.error);
    }
    return writer;
  },

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

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

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

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

  fromJSON(object: any): RemoveDocumentsResponse_Result {
    return {
      documentId: isSet(object.documentId)
        ? globalThis.String(object.documentId)
        : isSet(object.document_id)
        ? globalThis.String(object.document_id)
        : "",
      intentsDeleted: isSet(object.intentsDeleted)
        ? globalThis.Number(object.intentsDeleted)
        : isSet(object.intents_deleted)
        ? globalThis.Number(object.intents_deleted)
        : 0,
      error: isSet(object.error) ? globalThis.String(object.error) : "",
    };
  },

  toJSON(message: RemoveDocumentsResponse_Result): unknown {
    const obj: any = {};
    if (message.documentId !== "") {
      obj.documentId = message.documentId;
    }
    if (message.intentsDeleted !== 0) {
      obj.intentsDeleted = Math.round(message.intentsDeleted);
    }
    if (message.error !== "") {
      obj.error = message.error;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<RemoveDocumentsResponse_Result>, I>>(base?: I): RemoveDocumentsResponse_Result {
    return RemoveDocumentsResponse_Result.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<RemoveDocumentsResponse_Result>, I>>(
    object: I,
  ): RemoveDocumentsResponse_Result {
    const message = createBaseRemoveDocumentsResponse_Result();
    message.documentId = object.documentId ?? "";
    message.intentsDeleted = object.intentsDeleted ?? 0;
    message.error = object.error ?? "";
    return message;
  },
};

function createBaseGetDocumentStatusRequest(): GetDocumentStatusRequest {
  return { projectId: "", documentIds: [] };
}

export const GetDocumentStatusRequest: MessageFns<GetDocumentStatusRequest> = {
  encode(message: GetDocumentStatusRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.projectId !== "") {
      writer.uint32(10).string(message.projectId);
    }
    for (const v of message.documentIds) {
      writer.uint32(18).string(v!);
    }
    return writer;
  },

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

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

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

  fromJSON(object: any): GetDocumentStatusRequest {
    return {
      projectId: isSet(object.projectId)
        ? globalThis.String(object.projectId)
        : isSet(object.project_id)
        ? globalThis.String(object.project_id)
        : "",
      documentIds: globalThis.Array.isArray(object?.documentIds)
        ? object.documentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.document_ids)
        ? object.document_ids.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: GetDocumentStatusRequest): unknown {
    const obj: any = {};
    if (message.projectId !== "") {
      obj.projectId = message.projectId;
    }
    if (message.documentIds?.length) {
      obj.documentIds = message.documentIds;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetDocumentStatusRequest>, I>>(base?: I): GetDocumentStatusRequest {
    return GetDocumentStatusRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetDocumentStatusRequest>, I>>(object: I): GetDocumentStatusRequest {
    const message = createBaseGetDocumentStatusRequest();
    message.projectId = object.projectId ?? "";
    message.documentIds = object.documentIds?.map((e) => e) || [];
    return message;
  },
};

function createBaseGetDocumentStatusResponse(): GetDocumentStatusResponse {
  return { statuses: [] };
}

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

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

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

  fromJSON(object: any): GetDocumentStatusResponse {
    return {
      statuses: globalThis.Array.isArray(object?.statuses)
        ? object.statuses.map((e: any) => GetDocumentStatusResponse_Status.fromJSON(e))
        : [],
    };
  },

  toJSON(message: GetDocumentStatusResponse): unknown {
    const obj: any = {};
    if (message.statuses?.length) {
      obj.statuses = message.statuses.map((e) => GetDocumentStatusResponse_Status.toJSON(e));
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetDocumentStatusResponse>, I>>(base?: I): GetDocumentStatusResponse {
    return GetDocumentStatusResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetDocumentStatusResponse>, I>>(object: I): GetDocumentStatusResponse {
    const message = createBaseGetDocumentStatusResponse();
    message.statuses = object.statuses?.map((e) => GetDocumentStatusResponse_Status.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetDocumentStatusResponse_Status(): GetDocumentStatusResponse_Status {
  return { documentId: "", processingStatus: undefined, intentsCreated: 0, intentIds: [] };
}

export const GetDocumentStatusResponse_Status: MessageFns<GetDocumentStatusResponse_Status> = {
  encode(message: GetDocumentStatusResponse_Status, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.documentId !== "") {
      writer.uint32(10).string(message.documentId);
    }
    if (message.processingStatus !== undefined) {
      ProcessingStatus.encode(message.processingStatus, writer.uint32(18).fork()).join();
    }
    if (message.intentsCreated !== 0) {
      writer.uint32(24).int32(message.intentsCreated);
    }
    for (const v of message.intentIds) {
      writer.uint32(34).string(v!);
    }
    return writer;
  },

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

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

          message.processingStatus = ProcessingStatus.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

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

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

  fromJSON(object: any): GetDocumentStatusResponse_Status {
    return {
      documentId: isSet(object.documentId)
        ? globalThis.String(object.documentId)
        : isSet(object.document_id)
        ? globalThis.String(object.document_id)
        : "",
      processingStatus: isSet(object.processingStatus)
        ? ProcessingStatus.fromJSON(object.processingStatus)
        : isSet(object.processing_status)
        ? ProcessingStatus.fromJSON(object.processing_status)
        : undefined,
      intentsCreated: isSet(object.intentsCreated)
        ? globalThis.Number(object.intentsCreated)
        : isSet(object.intents_created)
        ? globalThis.Number(object.intents_created)
        : 0,
      intentIds: globalThis.Array.isArray(object?.intentIds)
        ? object.intentIds.map((e: any) => globalThis.String(e))
        : globalThis.Array.isArray(object?.intent_ids)
        ? object.intent_ids.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: GetDocumentStatusResponse_Status): unknown {
    const obj: any = {};
    if (message.documentId !== "") {
      obj.documentId = message.documentId;
    }
    if (message.processingStatus !== undefined) {
      obj.processingStatus = ProcessingStatus.toJSON(message.processingStatus);
    }
    if (message.intentsCreated !== 0) {
      obj.intentsCreated = Math.round(message.intentsCreated);
    }
    if (message.intentIds?.length) {
      obj.intentIds = message.intentIds;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetDocumentStatusResponse_Status>, I>>(
    base?: I,
  ): GetDocumentStatusResponse_Status {
    return GetDocumentStatusResponse_Status.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetDocumentStatusResponse_Status>, I>>(
    object: I,
  ): GetDocumentStatusResponse_Status {
    const message = createBaseGetDocumentStatusResponse_Status();
    message.documentId = object.documentId ?? "";
    message.processingStatus = (object.processingStatus !== undefined && object.processingStatus !== null)
      ? ProcessingStatus.fromPartial(object.processingStatus)
      : undefined;
    message.intentsCreated = object.intentsCreated ?? 0;
    message.intentIds = object.intentIds?.map((e) => e) || [];
    return message;
  },
};

function bytesFromBase64(b64: string): Uint8Array {
  if ((globalThis as any).Buffer) {
    return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64"));
  } else {
    const bin = globalThis.atob(b64);
    const arr = new Uint8Array(bin.length);
    for (let i = 0; i < bin.length; ++i) {
      arr[i] = bin.charCodeAt(i);
    }
    return arr;
  }
}

function base64FromBytes(arr: Uint8Array): string {
  if ((globalThis as any).Buffer) {
    return (globalThis as any).Buffer.from(arr).toString("base64");
  } else {
    const bin: string[] = [];
    arr.forEach((byte) => {
      bin.push(globalThis.String.fromCharCode(byte));
    });
    return globalThis.btoa(bin.join(""));
  }
}

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

export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

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 longToNumber(int64: { toString(): string }): number {
  const num = globalThis.Number(int64.toString());
  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
  }
  return num;
}

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

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
}