// @generated by protoc-gen-es v1.6.0 with parameter "target=ts"
// @generated from file content/content.proto (package content, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { DescriptorProto, EnumDescriptorProto, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { User } from "../user/user_pb.js";
import { Conversation } from "./chatgpt/conversation_pb.js";
import { History } from "./browser/history_pb.js";
import { HugoConfig, MenuItem } from "./blog_pb.js";

/**
 * @generated from message content.InferRequest
 */
export class InferRequest extends Message<InferRequest> {
  /**
   * @generated from field: string prompt = 1;
   */
  prompt = "";

  constructor(data?: PartialMessage<InferRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.InferRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "prompt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferRequest {
    return new InferRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferRequest {
    return new InferRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferRequest {
    return new InferRequest().fromJsonString(jsonString, options);
  }

  static equals(a: InferRequest | PlainMessage<InferRequest> | undefined, b: InferRequest | PlainMessage<InferRequest> | undefined): boolean {
    return proto3.util.equals(InferRequest, a, b);
  }
}

/**
 * @generated from message content.InferResponse
 */
export class InferResponse extends Message<InferResponse> {
  /**
   * @generated from field: string text = 1;
   */
  text = "";

  constructor(data?: PartialMessage<InferResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.InferResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferResponse {
    return new InferResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferResponse {
    return new InferResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferResponse {
    return new InferResponse().fromJsonString(jsonString, options);
  }

  static equals(a: InferResponse | PlainMessage<InferResponse> | undefined, b: InferResponse | PlainMessage<InferResponse> | undefined): boolean {
    return proto3.util.equals(InferResponse, a, b);
  }
}

/**
 * @generated from message content.TypesResponse
 */
export class TypesResponse extends Message<TypesResponse> {
  /**
   * @generated from field: content.GRPCTypeInfo content = 1;
   */
  content?: GRPCTypeInfo;

  /**
   * @generated from field: content.GRPCTypeInfo site = 2;
   */
  site?: GRPCTypeInfo;

  constructor(data?: PartialMessage<TypesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.TypesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content", kind: "message", T: GRPCTypeInfo },
    { no: 2, name: "site", kind: "message", T: GRPCTypeInfo },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TypesResponse {
    return new TypesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TypesResponse {
    return new TypesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TypesResponse {
    return new TypesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: TypesResponse | PlainMessage<TypesResponse> | undefined, b: TypesResponse | PlainMessage<TypesResponse> | undefined): boolean {
    return proto3.util.equals(TypesResponse, a, b);
  }
}

/**
 * @generated from message content.GetSourcesRequest
 */
export class GetSourcesRequest extends Message<GetSourcesRequest> {
  /**
   * @generated from field: repeated string content_types = 1;
   */
  contentTypes: string[] = [];

  /**
   * @generated from field: repeated string tags = 2;
   */
  tags: string[] = [];

  constructor(data?: PartialMessage<GetSourcesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.GetSourcesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 2, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetSourcesRequest {
    return new GetSourcesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetSourcesRequest {
    return new GetSourcesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetSourcesRequest {
    return new GetSourcesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetSourcesRequest | PlainMessage<GetSourcesRequest> | undefined, b: GetSourcesRequest | PlainMessage<GetSourcesRequest> | undefined): boolean {
    return proto3.util.equals(GetSourcesRequest, a, b);
  }
}

/**
 * @generated from message content.VoiceInputRequest
 */
export class VoiceInputRequest extends Message<VoiceInputRequest> {
  /**
   * @generated from field: int32 capture_device = 1;
   */
  captureDevice = 0;

  constructor(data?: PartialMessage<VoiceInputRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.VoiceInputRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "capture_device", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VoiceInputRequest {
    return new VoiceInputRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VoiceInputRequest {
    return new VoiceInputRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VoiceInputRequest {
    return new VoiceInputRequest().fromJsonString(jsonString, options);
  }

  static equals(a: VoiceInputRequest | PlainMessage<VoiceInputRequest> | undefined, b: VoiceInputRequest | PlainMessage<VoiceInputRequest> | undefined): boolean {
    return proto3.util.equals(VoiceInputRequest, a, b);
  }
}

/**
 * @generated from message content.VoiceInputResponse
 */
export class VoiceInputResponse extends Message<VoiceInputResponse> {
  /**
   * @generated from field: content.Segment segment = 1;
   */
  segment?: Segment;

  constructor(data?: PartialMessage<VoiceInputResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.VoiceInputResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "segment", kind: "message", T: Segment },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VoiceInputResponse {
    return new VoiceInputResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VoiceInputResponse {
    return new VoiceInputResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VoiceInputResponse {
    return new VoiceInputResponse().fromJsonString(jsonString, options);
  }

  static equals(a: VoiceInputResponse | PlainMessage<VoiceInputResponse> | undefined, b: VoiceInputResponse | PlainMessage<VoiceInputResponse> | undefined): boolean {
    return proto3.util.equals(VoiceInputResponse, a, b);
  }
}

/**
 * @generated from message content.RelateRequest
 */
export class RelateRequest extends Message<RelateRequest> {
  /**
   * @generated from field: string parent = 1;
   */
  parent = "";

  /**
   * @generated from field: repeated string children = 2;
   */
  children: string[] = [];

  /**
   * @generated from field: bool connect = 3;
   */
  connect = false;

  constructor(data?: PartialMessage<RelateRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.RelateRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "parent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "children", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 3, name: "connect", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RelateRequest {
    return new RelateRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RelateRequest {
    return new RelateRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RelateRequest {
    return new RelateRequest().fromJsonString(jsonString, options);
  }

  static equals(a: RelateRequest | PlainMessage<RelateRequest> | undefined, b: RelateRequest | PlainMessage<RelateRequest> | undefined): boolean {
    return proto3.util.equals(RelateRequest, a, b);
  }
}

/**
 * @generated from message content.Sources
 */
export class Sources extends Message<Sources> {
  /**
   * @generated from field: repeated content.EnumeratedSource sources = 1;
   */
  sources: EnumeratedSource[] = [];

  constructor(data?: PartialMessage<Sources>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Sources";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "sources", kind: "message", T: EnumeratedSource, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Sources {
    return new Sources().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Sources {
    return new Sources().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Sources {
    return new Sources().fromJsonString(jsonString, options);
  }

  static equals(a: Sources | PlainMessage<Sources> | undefined, b: Sources | PlainMessage<Sources> | undefined): boolean {
    return proto3.util.equals(Sources, a, b);
  }
}

/**
 * @generated from message content.EnumeratedSource
 */
export class EnumeratedSource extends Message<EnumeratedSource> {
  /**
   * @generated from field: content.Source source = 1;
   */
  source?: Source;

  /**
   * @generated from field: repeated content.DisplayContent display_content = 2;
   */
  displayContent: DisplayContent[] = [];

  constructor(data?: PartialMessage<EnumeratedSource>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.EnumeratedSource";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "source", kind: "message", T: Source },
    { no: 2, name: "display_content", kind: "message", T: DisplayContent, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnumeratedSource {
    return new EnumeratedSource().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnumeratedSource {
    return new EnumeratedSource().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnumeratedSource {
    return new EnumeratedSource().fromJsonString(jsonString, options);
  }

  static equals(a: EnumeratedSource | PlainMessage<EnumeratedSource> | undefined, b: EnumeratedSource | PlainMessage<EnumeratedSource> | undefined): boolean {
    return proto3.util.equals(EnumeratedSource, a, b);
  }
}

/**
 * @generated from message content.DisplayContent
 */
export class DisplayContent extends Message<DisplayContent> {
  /**
   * @generated from field: string title = 1;
   */
  title = "";

  /**
   * @generated from field: string description = 2;
   */
  description = "";

  /**
   * @generated from field: string type = 3;
   */
  type = "";

  /**
   * @generated from field: content.Content content = 4;
   */
  content?: Content;

  constructor(data?: PartialMessage<DisplayContent>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.DisplayContent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "content", kind: "message", T: Content },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisplayContent {
    return new DisplayContent().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisplayContent {
    return new DisplayContent().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisplayContent {
    return new DisplayContent().fromJsonString(jsonString, options);
  }

  static equals(a: DisplayContent | PlainMessage<DisplayContent> | undefined, b: DisplayContent | PlainMessage<DisplayContent> | undefined): boolean {
    return proto3.util.equals(DisplayContent, a, b);
  }
}

/**
 * @generated from message content.Source
 */
export class Source extends Message<Source> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * @generated from oneof content.Source.type
   */
  type: {
    /**
     * @generated from field: content.Server server = 2;
     */
    value: Server;
    case: "server";
  } | {
    /**
     * @generated from field: content.Folder folder = 3;
     */
    value: Folder;
    case: "folder";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Source>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Source";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "server", kind: "message", T: Server, oneof: "type" },
    { no: 3, name: "folder", kind: "message", T: Folder, oneof: "type" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Source {
    return new Source().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Source {
    return new Source().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Source {
    return new Source().fromJsonString(jsonString, options);
  }

  static equals(a: Source | PlainMessage<Source> | undefined, b: Source | PlainMessage<Source> | undefined): boolean {
    return proto3.util.equals(Source, a, b);
  }
}

/**
 * @generated from message content.Server
 */
export class Server extends Message<Server> {
  constructor(data?: PartialMessage<Server>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Server";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Server {
    return new Server().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Server {
    return new Server().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Server {
    return new Server().fromJsonString(jsonString, options);
  }

  static equals(a: Server | PlainMessage<Server> | undefined, b: Server | PlainMessage<Server> | undefined): boolean {
    return proto3.util.equals(Server, a, b);
  }
}

/**
 * @generated from message content.Folder
 */
export class Folder extends Message<Folder> {
  /**
   * @generated from field: string path = 2;
   */
  path = "";

  constructor(data?: PartialMessage<Folder>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Folder";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 2, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Folder {
    return new Folder().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Folder {
    return new Folder().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Folder {
    return new Folder().fromJsonString(jsonString, options);
  }

  static equals(a: Folder | PlainMessage<Folder> | undefined, b: Folder | PlainMessage<Folder> | undefined): boolean {
    return proto3.util.equals(Folder, a, b);
  }
}

/**
 * @generated from message content.SetTagsRequest
 */
export class SetTagsRequest extends Message<SetTagsRequest> {
  /**
   * @generated from field: string content_id = 1;
   */
  contentId = "";

  /**
   * @generated from field: repeated string tags = 2;
   */
  tags: string[] = [];

  constructor(data?: PartialMessage<SetTagsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.SetTagsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetTagsRequest {
    return new SetTagsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetTagsRequest {
    return new SetTagsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetTagsRequest {
    return new SetTagsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: SetTagsRequest | PlainMessage<SetTagsRequest> | undefined, b: SetTagsRequest | PlainMessage<SetTagsRequest> | undefined): boolean {
    return proto3.util.equals(SetTagsRequest, a, b);
  }
}

/**
 * @generated from message content.TagRequest
 */
export class TagRequest extends Message<TagRequest> {
  /**
   * @generated from field: string group_id = 1;
   */
  groupId = "";

  constructor(data?: PartialMessage<TagRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.TagRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "group_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TagRequest {
    return new TagRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TagRequest {
    return new TagRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TagRequest {
    return new TagRequest().fromJsonString(jsonString, options);
  }

  static equals(a: TagRequest | PlainMessage<TagRequest> | undefined, b: TagRequest | PlainMessage<TagRequest> | undefined): boolean {
    return proto3.util.equals(TagRequest, a, b);
  }
}

/**
 * @generated from message content.Tags
 */
export class Tags extends Message<Tags> {
  /**
   * @generated from field: repeated content.Tag tags = 1;
   */
  tags: Tag[] = [];

  constructor(data?: PartialMessage<Tags>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Tags";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "tags", kind: "message", T: Tag, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Tags {
    return new Tags().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Tags {
    return new Tags().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Tags {
    return new Tags().fromJsonString(jsonString, options);
  }

  static equals(a: Tags | PlainMessage<Tags> | undefined, b: Tags | PlainMessage<Tags> | undefined): boolean {
    return proto3.util.equals(Tags, a, b);
  }
}

/**
 * @generated from message content.Tag
 */
export class Tag extends Message<Tag> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * @generated from field: repeated content.Tag sub_tags = 2;
   */
  subTags: Tag[] = [];

  constructor(data?: PartialMessage<Tag>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Tag";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "sub_tags", kind: "message", T: Tag, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Tag {
    return new Tag().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Tag {
    return new Tag().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Tag {
    return new Tag().fromJsonString(jsonString, options);
  }

  static equals(a: Tag | PlainMessage<Tag> | undefined, b: Tag | PlainMessage<Tag> | undefined): boolean {
    return proto3.util.equals(Tag, a, b);
  }
}

/**
 * @generated from message content.ContentIDs
 */
export class ContentIDs extends Message<ContentIDs> {
  /**
   * @generated from field: repeated string content_ids = 1;
   */
  contentIds: string[] = [];

  constructor(data?: PartialMessage<ContentIDs>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.ContentIDs";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContentIDs {
    return new ContentIDs().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContentIDs {
    return new ContentIDs().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContentIDs {
    return new ContentIDs().fromJsonString(jsonString, options);
  }

  static equals(a: ContentIDs | PlainMessage<ContentIDs> | undefined, b: ContentIDs | PlainMessage<ContentIDs> | undefined): boolean {
    return proto3.util.equals(ContentIDs, a, b);
  }
}

/**
 * @generated from message content.Contents
 */
export class Contents extends Message<Contents> {
  /**
   * @generated from field: content.Content content = 1;
   */
  content?: Content;

  /**
   * @generated from field: repeated string tags = 2;
   */
  tags: string[] = [];

  /**
   * @generated from field: repeated content.Content related = 3;
   */
  related: Content[] = [];

  /**
   * @generated from field: repeated string parents = 4;
   */
  parents: string[] = [];

  constructor(data?: PartialMessage<Contents>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Contents";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content", kind: "message", T: Content },
    { no: 2, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 3, name: "related", kind: "message", T: Content, repeated: true },
    { no: 4, name: "parents", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Contents {
    return new Contents().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Contents {
    return new Contents().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Contents {
    return new Contents().fromJsonString(jsonString, options);
  }

  static equals(a: Contents | PlainMessage<Contents> | undefined, b: Contents | PlainMessage<Contents> | undefined): boolean {
    return proto3.util.equals(Contents, a, b);
  }
}

/**
 * @generated from message content.Query
 */
export class Query extends Message<Query> {
  /**
   * @generated from field: string query = 1;
   */
  query = "";

  /**
   * @generated from field: uint32 page = 2;
   */
  page = 0;

  /**
   * @generated from field: string contentID = 3;
   */
  contentID = "";

  /**
   * @generated from field: string groupID = 4;
   */
  groupID = "";

  /**
   * @generated from field: repeated string tags = 5;
   */
  tags: string[] = [];

  /**
   * @generated from field: repeated string content_types = 6;
   */
  contentTypes: string[] = [];

  constructor(data?: PartialMessage<Query>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Query";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "query", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "page", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "contentID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "groupID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 6, name: "content_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Query {
    return new Query().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Query {
    return new Query().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Query {
    return new Query().fromJsonString(jsonString, options);
  }

  static equals(a: Query | PlainMessage<Query> | undefined, b: Query | PlainMessage<Query> | undefined): boolean {
    return proto3.util.equals(Query, a, b);
  }
}

/**
 * @generated from message content.Results
 */
export class Results extends Message<Results> {
  /**
   * @generated from field: repeated content.StoredContent storedContent = 1;
   */
  storedContent: StoredContent[] = [];

  constructor(data?: PartialMessage<Results>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Results";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "storedContent", kind: "message", T: StoredContent, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Results {
    return new Results().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Results {
    return new Results().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Results {
    return new Results().fromJsonString(jsonString, options);
  }

  static equals(a: Results | PlainMessage<Results> | undefined, b: Results | PlainMessage<Results> | undefined): boolean {
    return proto3.util.equals(Results, a, b);
  }
}

/**
 * @generated from message content.StoredContent
 */
export class StoredContent extends Message<StoredContent> {
  /**
   * @generated from field: content.Content content = 1;
   */
  content?: Content;

  /**
   * @generated from field: string id = 2;
   */
  id = "";

  /**
   * @generated from field: repeated content.Content related = 3;
   */
  related: Content[] = [];

  /**
   * @generated from field: string title = 4;
   */
  title = "";

  /**
   * @generated from field: string description = 5;
   */
  description = "";

  /**
   * @generated from field: string image = 6;
   */
  image = "";

  /**
   * @generated from field: string url = 7;
   */
  url = "";

  /**
   * @generated from field: user.User user = 9;
   */
  user?: User;

  /**
   * @generated from field: repeated content.Tag tags = 10;
   */
  tags: Tag[] = [];

  /**
   * @generated from field: string preview = 11;
   */
  preview = "";

  constructor(data?: PartialMessage<StoredContent>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.StoredContent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "content", kind: "message", T: Content },
    { no: 2, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "related", kind: "message", T: Content, repeated: true },
    { no: 4, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "image", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "user", kind: "message", T: User },
    { no: 10, name: "tags", kind: "message", T: Tag, repeated: true },
    { no: 11, name: "preview", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StoredContent {
    return new StoredContent().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StoredContent {
    return new StoredContent().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StoredContent {
    return new StoredContent().fromJsonString(jsonString, options);
  }

  static equals(a: StoredContent | PlainMessage<StoredContent> | undefined, b: StoredContent | PlainMessage<StoredContent> | undefined): boolean {
    return proto3.util.equals(StoredContent, a, b);
  }
}

/**
 * @generated from message content.Edge
 */
export class Edge extends Message<Edge> {
  /**
   * @generated from field: string from = 1;
   */
  from = "";

  /**
   * @generated from field: string to = 2;
   */
  to = "";

  constructor(data?: PartialMessage<Edge>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Edge";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "from", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "to", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Edge {
    return new Edge().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Edge {
    return new Edge().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Edge {
    return new Edge().fromJsonString(jsonString, options);
  }

  static equals(a: Edge | PlainMessage<Edge> | undefined, b: Edge | PlainMessage<Edge> | undefined): boolean {
    return proto3.util.equals(Edge, a, b);
  }
}

/**
 * Content has data and metadata
 *
 * @generated from message content.Content
 */
export class Content extends Message<Content> {
  /**
   * @generated from field: repeated string tags = 1;
   */
  tags: string[] = [];

  /**
   * @generated from field: string created_at = 2;
   */
  createdAt = "";

  /**
   * @generated from field: string uri = 3;
   */
  uri = "";

  /**
   * @generated from field: string id = 4;
   */
  id = "";

  /**
   * @generated from oneof content.Content.type
   */
  type: {
    /**
     * @generated from field: content.Data data = 6;
     */
    value: Data;
    case: "data";
  } | {
    /**
     * @generated from field: content.Normalized normalized = 7;
     */
    value: Normalized;
    case: "normalized";
  } | {
    /**
     * @generated from field: content.Transformed transformed = 8;
     */
    value: Transformed;
    case: "transformed";
  } | {
    /**
     * @generated from field: content.Post post = 9;
     */
    value: Post;
    case: "post";
  } | {
    /**
     * @generated from field: content.Site site = 10;
     */
    value: Site;
    case: "site";
  } | {
    /**
     * @generated from field: chatgpt.Conversation chatgpt_conversation = 11;
     */
    value: Conversation;
    case: "chatgptConversation";
  } | {
    /**
     * @generated from field: browser.History browser_history = 12;
     */
    value: History;
    case: "browserHistory";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Content>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Content";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 2, name: "created_at", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "uri", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "data", kind: "message", T: Data, oneof: "type" },
    { no: 7, name: "normalized", kind: "message", T: Normalized, oneof: "type" },
    { no: 8, name: "transformed", kind: "message", T: Transformed, oneof: "type" },
    { no: 9, name: "post", kind: "message", T: Post, oneof: "type" },
    { no: 10, name: "site", kind: "message", T: Site, oneof: "type" },
    { no: 11, name: "chatgpt_conversation", kind: "message", T: Conversation, oneof: "type" },
    { no: 12, name: "browser_history", kind: "message", T: History, oneof: "type" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Content {
    return new Content().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Content {
    return new Content().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Content {
    return new Content().fromJsonString(jsonString, options);
  }

  static equals(a: Content | PlainMessage<Content> | undefined, b: Content | PlainMessage<Content> | undefined): boolean {
    return proto3.util.equals(Content, a, b);
  }
}

/**
 * @generated from message content.Post
 */
export class Post extends Message<Post> {
  /**
   * @generated from field: string title = 1;
   */
  title = "";

  /**
   * @generated from field: string summary = 2;
   */
  summary = "";

  /**
   * @generated from field: string content = 3;
   */
  content = "";

  /**
   * @generated from field: repeated string authors = 4;
   */
  authors: string[] = [];

  /**
   * @generated from field: bool draft = 6;
   */
  draft = false;

  constructor(data?: PartialMessage<Post>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Post";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "content", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "authors", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 6, name: "draft", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Post {
    return new Post().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Post {
    return new Post().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Post {
    return new Post().fromJsonString(jsonString, options);
  }

  static equals(a: Post | PlainMessage<Post> | undefined, b: Post | PlainMessage<Post> | undefined): boolean {
    return proto3.util.equals(Post, a, b);
  }
}

/**
 * @generated from message content.GitRepo
 */
export class GitRepo extends Message<GitRepo> {
  /**
   * @generated from field: string url = 1;
   */
  url = "";

  constructor(data?: PartialMessage<GitRepo>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.GitRepo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GitRepo {
    return new GitRepo().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GitRepo {
    return new GitRepo().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GitRepo {
    return new GitRepo().fromJsonString(jsonString, options);
  }

  static equals(a: GitRepo | PlainMessage<GitRepo> | undefined, b: GitRepo | PlainMessage<GitRepo> | undefined): boolean {
    return proto3.util.equals(GitRepo, a, b);
  }
}

/**
 * @generated from message content.Data
 */
export class Data extends Message<Data> {
  /**
   * @generated from oneof content.Data.type
   */
  type: {
    /**
     * @generated from field: content.Text text = 4;
     */
    value: Text;
    case: "text";
  } | {
    /**
     * @generated from field: content.File file = 5;
     */
    value: File;
    case: "file";
  } | {
    /**
     * @generated from field: content.URL url = 6;
     */
    value: URL;
    case: "url";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Data>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Data";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 4, name: "text", kind: "message", T: Text, oneof: "type" },
    { no: 5, name: "file", kind: "message", T: File, oneof: "type" },
    { no: 6, name: "url", kind: "message", T: URL, oneof: "type" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Data {
    return new Data().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Data {
    return new Data().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Data {
    return new Data().fromJsonString(jsonString, options);
  }

  static equals(a: Data | PlainMessage<Data> | undefined, b: Data | PlainMessage<Data> | undefined): boolean {
    return proto3.util.equals(Data, a, b);
  }
}

/**
 * @generated from message content.Normalized
 */
export class Normalized extends Message<Normalized> {
  /**
   * @generated from oneof content.Normalized.type
   */
  type: {
    /**
     * @generated from field: content.Article article = 3;
     */
    value: Article;
    case: "article";
  } | {
    /**
     * @generated from field: content.HTML html = 4;
     */
    value: HTML;
    case: "html";
  } | {
    /**
     * @generated from field: content.Transcript transcript = 6;
     */
    value: Transcript;
    case: "transcript";
  } | {
    /**
     * @generated from field: content.ReadMe readme = 7;
     */
    value: ReadMe;
    case: "readme";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Normalized>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Normalized";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 3, name: "article", kind: "message", T: Article, oneof: "type" },
    { no: 4, name: "html", kind: "message", T: HTML, oneof: "type" },
    { no: 6, name: "transcript", kind: "message", T: Transcript, oneof: "type" },
    { no: 7, name: "readme", kind: "message", T: ReadMe, oneof: "type" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Normalized {
    return new Normalized().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Normalized {
    return new Normalized().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Normalized {
    return new Normalized().fromJsonString(jsonString, options);
  }

  static equals(a: Normalized | PlainMessage<Normalized> | undefined, b: Normalized | PlainMessage<Normalized> | undefined): boolean {
    return proto3.util.equals(Normalized, a, b);
  }
}

/**
 * @generated from message content.Transformed
 */
export class Transformed extends Message<Transformed> {
  /**
   * @generated from oneof content.Transformed.type
   */
  type: {
    /**
     * @generated from field: content.Summary summary = 1;
     */
    value: Summary;
    case: "summary";
  } | {
    /**
     * @generated from field: content.Categories categories = 2;
     */
    value: Categories;
    case: "categories";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<Transformed>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Transformed";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "summary", kind: "message", T: Summary, oneof: "type" },
    { no: 2, name: "categories", kind: "message", T: Categories, oneof: "type" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Transformed {
    return new Transformed().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Transformed {
    return new Transformed().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Transformed {
    return new Transformed().fromJsonString(jsonString, options);
  }

  static equals(a: Transformed | PlainMessage<Transformed> | undefined, b: Transformed | PlainMessage<Transformed> | undefined): boolean {
    return proto3.util.equals(Transformed, a, b);
  }
}

/**
 * @generated from message content.Article
 */
export class Article extends Message<Article> {
  /**
   * @generated from field: string title = 1;
   */
  title = "";

  /**
   * @generated from field: string author = 2;
   */
  author = "";

  /**
   * @generated from field: int32 length = 3;
   */
  length = 0;

  /**
   * @generated from field: string excerpt = 4;
   */
  excerpt = "";

  /**
   * @generated from field: string site_name = 5;
   */
  siteName = "";

  /**
   * @generated from field: string image = 6;
   */
  image = "";

  /**
   * @generated from field: string favicon = 7;
   */
  favicon = "";

  /**
   * @generated from field: string text = 8;
   */
  text = "";

  constructor(data?: PartialMessage<Article>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Article";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "author", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "length", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 4, name: "excerpt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "site_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "image", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "favicon", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Article {
    return new Article().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Article {
    return new Article().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Article {
    return new Article().fromJsonString(jsonString, options);
  }

  static equals(a: Article | PlainMessage<Article> | undefined, b: Article | PlainMessage<Article> | undefined): boolean {
    return proto3.util.equals(Article, a, b);
  }
}

/**
 * @generated from message content.HTML
 */
export class HTML extends Message<HTML> {
  /**
   * @generated from field: string html = 1;
   */
  html = "";

  constructor(data?: PartialMessage<HTML>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.HTML";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "html", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HTML {
    return new HTML().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HTML {
    return new HTML().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HTML {
    return new HTML().fromJsonString(jsonString, options);
  }

  static equals(a: HTML | PlainMessage<HTML> | undefined, b: HTML | PlainMessage<HTML> | undefined): boolean {
    return proto3.util.equals(HTML, a, b);
  }
}

/**
 * @generated from message content.ReadMe
 */
export class ReadMe extends Message<ReadMe> {
  /**
   * @generated from field: string data = 1;
   */
  data = "";

  constructor(data?: PartialMessage<ReadMe>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.ReadMe";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "data", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReadMe {
    return new ReadMe().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReadMe {
    return new ReadMe().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReadMe {
    return new ReadMe().fromJsonString(jsonString, options);
  }

  static equals(a: ReadMe | PlainMessage<ReadMe> | undefined, b: ReadMe | PlainMessage<ReadMe> | undefined): boolean {
    return proto3.util.equals(ReadMe, a, b);
  }
}

/**
 * @generated from message content.Summary
 */
export class Summary extends Message<Summary> {
  /**
   * @generated from field: string summary = 1;
   */
  summary = "";

  constructor(data?: PartialMessage<Summary>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Summary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Summary {
    return new Summary().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Summary {
    return new Summary().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Summary {
    return new Summary().fromJsonString(jsonString, options);
  }

  static equals(a: Summary | PlainMessage<Summary> | undefined, b: Summary | PlainMessage<Summary> | undefined): boolean {
    return proto3.util.equals(Summary, a, b);
  }
}

/**
 * @generated from message content.Categories
 */
export class Categories extends Message<Categories> {
  /**
   * @generated from field: repeated string categories = 1;
   */
  categories: string[] = [];

  constructor(data?: PartialMessage<Categories>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Categories";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "categories", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Categories {
    return new Categories().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Categories {
    return new Categories().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Categories {
    return new Categories().fromJsonString(jsonString, options);
  }

  static equals(a: Categories | PlainMessage<Categories> | undefined, b: Categories | PlainMessage<Categories> | undefined): boolean {
    return proto3.util.equals(Categories, a, b);
  }
}

/**
 * @generated from message content.File
 */
export class File extends Message<File> {
  /**
   * @generated from field: string file = 1;
   */
  file = "";

  /**
   * @generated from field: bytes data = 2;
   */
  data = new Uint8Array(0);

  /**
   * @generated from field: string url = 3;
   */
  url = "";

  constructor(data?: PartialMessage<File>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.File";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "file", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
    { no: 3, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): File {
    return new File().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): File {
    return new File().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): File {
    return new File().fromJsonString(jsonString, options);
  }

  static equals(a: File | PlainMessage<File> | undefined, b: File | PlainMessage<File> | undefined): boolean {
    return proto3.util.equals(File, a, b);
  }
}

/**
 * @generated from message content.Text
 */
export class Text extends Message<Text> {
  /**
   * @generated from field: string data = 1;
   */
  data = "";

  constructor(data?: PartialMessage<Text>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Text";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "data", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Text {
    return new Text().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Text {
    return new Text().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Text {
    return new Text().fromJsonString(jsonString, options);
  }

  static equals(a: Text | PlainMessage<Text> | undefined, b: Text | PlainMessage<Text> | undefined): boolean {
    return proto3.util.equals(Text, a, b);
  }
}

/**
 * @generated from message content.URL
 */
export class URL extends Message<URL> {
  /**
   * @generated from field: string url = 1;
   */
  url = "";

  /**
   * @generated from field: bool crawl = 2;
   */
  crawl = false;

  /**
   * @generated from field: string title = 3;
   */
  title = "";

  constructor(data?: PartialMessage<URL>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.URL";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "crawl", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): URL {
    return new URL().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): URL {
    return new URL().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): URL {
    return new URL().fromJsonString(jsonString, options);
  }

  static equals(a: URL | PlainMessage<URL> | undefined, b: URL | PlainMessage<URL> | undefined): boolean {
    return proto3.util.equals(URL, a, b);
  }
}

/**
 * @generated from message content.Token
 */
export class Token extends Message<Token> {
  /**
   * @generated from field: uint32 id = 1;
   */
  id = 0;

  /**
   * @generated from field: uint64 start_time = 2;
   */
  startTime = protoInt64.zero;

  /**
   * @generated from field: uint64 end_time = 3;
   */
  endTime = protoInt64.zero;

  /**
   * @generated from field: string text = 4;
   */
  text = "";

  /**
   * @generated from field: string p = 5;
   */
  p = "";

  constructor(data?: PartialMessage<Token>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Token";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 2, name: "start_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 3, name: "end_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 4, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "p", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Token {
    return new Token().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Token {
    return new Token().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Token {
    return new Token().fromJsonString(jsonString, options);
  }

  static equals(a: Token | PlainMessage<Token> | undefined, b: Token | PlainMessage<Token> | undefined): boolean {
    return proto3.util.equals(Token, a, b);
  }
}

/**
 * @generated from message content.Segment
 */
export class Segment extends Message<Segment> {
  /**
   * @generated from field: uint32 num = 1;
   */
  num = 0;

  /**
   * @generated from field: repeated content.Token tokens = 2;
   */
  tokens: Token[] = [];

  /**
   * @generated from field: string text = 3;
   */
  text = "";

  /**
   * @generated from field: uint64 start_time = 4;
   */
  startTime = protoInt64.zero;

  /**
   * @generated from field: uint64 end_time = 5;
   */
  endTime = protoInt64.zero;

  constructor(data?: PartialMessage<Segment>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Segment";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "num", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 2, name: "tokens", kind: "message", T: Token, repeated: true },
    { no: 3, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "start_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
    { no: 5, name: "end_time", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Segment {
    return new Segment().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Segment {
    return new Segment().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Segment {
    return new Segment().fromJsonString(jsonString, options);
  }

  static equals(a: Segment | PlainMessage<Segment> | undefined, b: Segment | PlainMessage<Segment> | undefined): boolean {
    return proto3.util.equals(Segment, a, b);
  }
}

/**
 * @generated from message content.Transcript
 */
export class Transcript extends Message<Transcript> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: repeated content.Segment segments = 3;
   */
  segments: Segment[] = [];

  constructor(data?: PartialMessage<Transcript>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Transcript";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "segments", kind: "message", T: Segment, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Transcript {
    return new Transcript().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Transcript {
    return new Transcript().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Transcript {
    return new Transcript().fromJsonString(jsonString, options);
  }

  static equals(a: Transcript | PlainMessage<Transcript> | undefined, b: Transcript | PlainMessage<Transcript> | undefined): boolean {
    return proto3.util.equals(Transcript, a, b);
  }
}

/**
 * @generated from message content.GRPCTypeInfo
 */
export class GRPCTypeInfo extends Message<GRPCTypeInfo> {
  /**
   * @generated from field: google.protobuf.DescriptorProto msg = 1;
   */
  msg?: DescriptorProto;

  /**
   * @generated from field: map<string, google.protobuf.DescriptorProto> desc_lookup = 3;
   */
  descLookup: { [key: string]: DescriptorProto } = {};

  /**
   * @generated from field: map<string, google.protobuf.EnumDescriptorProto> enum_lookup = 4;
   */
  enumLookup: { [key: string]: EnumDescriptorProto } = {};

  /**
   * @generated from field: string package_name = 6;
   */
  packageName = "";

  constructor(data?: PartialMessage<GRPCTypeInfo>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.GRPCTypeInfo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "msg", kind: "message", T: DescriptorProto },
    { no: 3, name: "desc_lookup", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: DescriptorProto} },
    { no: 4, name: "enum_lookup", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: EnumDescriptorProto} },
    { no: 6, name: "package_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GRPCTypeInfo {
    return new GRPCTypeInfo().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GRPCTypeInfo {
    return new GRPCTypeInfo().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GRPCTypeInfo {
    return new GRPCTypeInfo().fromJsonString(jsonString, options);
  }

  static equals(a: GRPCTypeInfo | PlainMessage<GRPCTypeInfo> | undefined, b: GRPCTypeInfo | PlainMessage<GRPCTypeInfo> | undefined): boolean {
    return proto3.util.equals(GRPCTypeInfo, a, b);
  }
}

/**
 * @generated from message content.Site
 */
export class Site extends Message<Site> {
  /**
   * @generated from field: repeated content.Section sections = 1;
   */
  sections: Section[] = [];

  /**
   * @generated from field: content.HugoConfig hugo_config = 2;
   */
  hugoConfig?: HugoConfig;

  constructor(data?: PartialMessage<Site>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Site";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "sections", kind: "message", T: Section, repeated: true },
    { no: 2, name: "hugo_config", kind: "message", T: HugoConfig },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Site {
    return new Site().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Site {
    return new Site().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Site {
    return new Site().fromJsonString(jsonString, options);
  }

  static equals(a: Site | PlainMessage<Site> | undefined, b: Site | PlainMessage<Site> | undefined): boolean {
    return proto3.util.equals(Site, a, b);
  }
}

/**
 * @generated from message content.Section
 */
export class Section extends Message<Section> {
  /**
   * TODO breadchris tags should be a filter that can have AND, OR, regex?
   *
   * @generated from field: repeated string tags = 1;
   */
  tags: string[] = [];

  /**
   * @generated from field: content.MenuItem menu = 2;
   */
  menu?: MenuItem;

  constructor(data?: PartialMessage<Section>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "content.Section";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 2, name: "menu", kind: "message", T: MenuItem },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Section {
    return new Section().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Section {
    return new Section().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Section {
    return new Section().fromJsonString(jsonString, options);
  }

  static equals(a: Section | PlainMessage<Section> | undefined, b: Section | PlainMessage<Section> | undefined): boolean {
    return proto3.util.equals(Section, a, b);
  }
}

