repository_pb.ts

// Copyright 2021-2024 Buf Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// @generated by protoc-gen-es v1.7.0 with parameter "ts_nocheck=false,target=ts"
// @generated from file buf/alpha/registry/v1alpha1/repository.proto (package buf.alpha.registry.v1alpha1, syntax proto3)
/* eslint-disable */

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
import { User } from "./user_pb.js";
import { RepositoryRole } from "./role_pb.js";

/**
 * @generated from enum buf.alpha.registry.v1alpha1.Visibility
 */
export enum Visibility {
  /**
   * @generated from enum value: VISIBILITY_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * @generated from enum value: VISIBILITY_PUBLIC = 1;
   */
  PUBLIC = 1,

  /**
   * @generated from enum value: VISIBILITY_PRIVATE = 2;
   */
  PRIVATE = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(Visibility)
proto3.util.setEnumType(Visibility, "buf.alpha.registry.v1alpha1.Visibility", [
  { no: 0, name: "VISIBILITY_UNSPECIFIED" },
  { no: 1, name: "VISIBILITY_PUBLIC" },
  { no: 2, name: "VISIBILITY_PRIVATE" },
]);

/**
 * @generated from message buf.alpha.registry.v1alpha1.Repository
 */
export class Repository extends Message<Repository> {
  /**
   * primary key, unique, immutable
   *
   * @generated from field: string id = 1;
   */
  id = "";

  /**
   * immutable
   *
   * @generated from field: google.protobuf.Timestamp create_time = 2;
   */
  createTime?: Timestamp;

  /**
   * mutable
   *
   * @generated from field: google.protobuf.Timestamp update_time = 3;
   */
  updateTime?: Timestamp;

  /**
   * unique, mutable
   *
   * @generated from field: string name = 4;
   */
  name = "";

  /**
   * @generated from oneof buf.alpha.registry.v1alpha1.Repository.owner
   */
  owner: {
    /**
     * foreign key, mutable
     *
     * @generated from field: string user_id = 5;
     */
    value: string;
    case: "userId";
  } | {
    /**
     * foreign key, mutable
     *
     * @generated from field: string organization_id = 6;
     */
    value: string;
    case: "organizationId";
  } | { case: undefined; value?: undefined } = { case: undefined };

  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Visibility visibility = 7;
   */
  visibility = Visibility.UNSPECIFIED;

  /**
   * deprecated means this repository is deprecated.
   *
   * @generated from field: bool deprecated = 8;
   */
  deprecated = false;

  /**
   * deprecation_message is the message shown if the repository is deprecated.
   *
   * @generated from field: string deprecation_message = 9;
   */
  deprecationMessage = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.Repository";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "create_time", kind: "message", T: Timestamp },
    { no: 3, name: "update_time", kind: "message", T: Timestamp },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "user_id", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "owner" },
    { no: 6, name: "organization_id", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "owner" },
    { no: 7, name: "visibility", kind: "enum", T: proto3.getEnumType(Visibility) },
    { no: 8, name: "deprecated", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 9, name: "deprecation_message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.RepositoryContributor
 */
export class RepositoryContributor extends Message<RepositoryContributor> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.User user = 1;
   */
  user?: User;

  /**
   * The ID of the for which the role belongs to.
   *
   * @generated from field: string repository_id = 2;
   */
  repositoryId = "";

  /**
   * The role that the user has been explicitly assigned against the repository.
   *
   * @generated from field: buf.alpha.registry.v1alpha1.RepositoryRole explicit_role = 3;
   */
  explicitRole = RepositoryRole.UNSPECIFIED;

  /**
   * Optionally defines the role that the user has implicitly against the repository through the owning organization.
   * If the repository does not belong to an organization or the user is not part of the owning organization, this is unset.
   *
   * @generated from field: buf.alpha.registry.v1alpha1.RepositoryRole implicit_role = 4;
   */
  implicitRole = RepositoryRole.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.RepositoryContributor";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "user", kind: "message", T: User },
    { no: 2, name: "repository_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "explicit_role", kind: "enum", T: proto3.getEnumType(RepositoryRole) },
    { no: 4, name: "implicit_role", kind: "enum", T: proto3.getEnumType(RepositoryRole) },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoriesByFullNameRequest
 */
export class GetRepositoriesByFullNameRequest extends Message<GetRepositoriesByFullNameRequest> {
  /**
   * minimum length is 1
   * maximum length is 250
   *
   * @generated from field: repeated string full_names = 1;
   */
  fullNames: string[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoriesByFullNameResponse
 */
export class GetRepositoriesByFullNameResponse extends Message<GetRepositoriesByFullNameResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.Repository repositories = 1;
   */
  repositories: Repository[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositoriesByFullNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repositories", kind: "message", T: Repository, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoryRequest
 */
export class GetRepositoryRequest extends Message<GetRepositoryRequest> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositoryRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoryResponse
 */
export class GetRepositoryResponse extends Message<GetRepositoryResponse> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Repository repository = 1;
   */
  repository?: Repository;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositoryResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository", kind: "message", T: Repository },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoryByFullNameRequest
 */
export class GetRepositoryByFullNameRequest extends Message<GetRepositoryByFullNameRequest> {
  /**
   * @generated from field: string full_name = 1;
   */
  fullName = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositoryByFullNameRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "full_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositoryByFullNameResponse
 */
export class GetRepositoryByFullNameResponse extends Message<GetRepositoryByFullNameResponse> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Repository repository = 1;
   */
  repository?: Repository;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositoryByFullNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository", kind: "message", T: Repository },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoriesRequest
 */
export class ListRepositoriesRequest extends Message<ListRepositoriesRequest> {
  /**
   * @generated from field: uint32 page_size = 1;
   */
  pageSize = 0;

  /**
   * The first page is returned if this is empty.
   *
   * @generated from field: string page_token = 2;
   */
  pageToken = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoriesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 2, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoriesResponse
 */
export class ListRepositoriesResponse extends Message<ListRepositoriesResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.Repository repositories = 1;
   */
  repositories: Repository[] = [];

  /**
   * There are no more pages if this is empty.
   *
   * @generated from field: string next_page_token = 2;
   */
  nextPageToken = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoriesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repositories", kind: "message", T: Repository, repeated: true },
    { no: 2, name: "next_page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListUserRepositoriesRequest
 */
export class ListUserRepositoriesRequest extends Message<ListUserRepositoriesRequest> {
  /**
   * The ID of the user whose repositories should be listed.
   *
   * @generated from field: string user_id = 1;
   */
  userId = "";

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

  /**
   * The first page is returned if this is empty.
   *
   * @generated from field: string page_token = 3;
   */
  pageToken = "";

  /**
   * @generated from field: bool reverse = 4;
   */
  reverse = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListUserRepositoriesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "user_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListUserRepositoriesResponse
 */
export class ListUserRepositoriesResponse extends Message<ListUserRepositoriesResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.Repository repositories = 1;
   */
  repositories: Repository[] = [];

  /**
   * There are no more pages if this is empty.
   *
   * @generated from field: string next_page_token = 2;
   */
  nextPageToken = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListUserRepositoriesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repositories", kind: "message", T: Repository, repeated: true },
    { no: 2, name: "next_page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoriesUserCanAccessRequest
 */
export class ListRepositoriesUserCanAccessRequest extends Message<ListRepositoriesUserCanAccessRequest> {
  /**
   * @generated from field: uint32 page_size = 1;
   */
  pageSize = 0;

  /**
   * The first page is returned if this is empty.
   *
   * @generated from field: string page_token = 2;
   */
  pageToken = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoriesUserCanAccessRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 2, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoriesUserCanAccessResponse
 */
export class ListRepositoriesUserCanAccessResponse extends Message<ListRepositoriesUserCanAccessResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.Repository repositories = 1;
   */
  repositories: Repository[] = [];

  /**
   * There are no more pages if this is empty.
   *
   * @generated from field: string next_page_token = 2;
   */
  nextPageToken = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoriesUserCanAccessResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repositories", kind: "message", T: Repository, repeated: true },
    { no: 2, name: "next_page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListOrganizationRepositoriesRequest
 */
export class ListOrganizationRepositoriesRequest extends Message<ListOrganizationRepositoriesRequest> {
  /**
   * The ID of the organization whose repositories should be listed.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

  /**
   * The first page is returned if this is empty.
   *
   * @generated from field: string page_token = 3;
   */
  pageToken = "";

  /**
   * @generated from field: bool reverse = 4;
   */
  reverse = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListOrganizationRepositoriesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "organization_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListOrganizationRepositoriesResponse
 */
export class ListOrganizationRepositoriesResponse extends Message<ListOrganizationRepositoriesResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.Repository repositories = 1;
   */
  repositories: Repository[] = [];

  /**
   * There are no more pages if this is empty.
   *
   * @generated from field: string next_page_token = 2;
   */
  nextPageToken = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListOrganizationRepositoriesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repositories", kind: "message", T: Repository, repeated: true },
    { no: 2, name: "next_page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.CreateRepositoryByFullNameRequest
 */
export class CreateRepositoryByFullNameRequest extends Message<CreateRepositoryByFullNameRequest> {
  /**
   * Must be unique across repositories.
   *
   * @generated from field: string full_name = 1;
   */
  fullName = "";

  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Visibility visibility = 2;
   */
  visibility = Visibility.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.CreateRepositoryByFullNameRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "full_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "visibility", kind: "enum", T: proto3.getEnumType(Visibility) },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.CreateRepositoryByFullNameResponse
 */
export class CreateRepositoryByFullNameResponse extends Message<CreateRepositoryByFullNameResponse> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Repository repository = 1;
   */
  repository?: Repository;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.CreateRepositoryByFullNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository", kind: "message", T: Repository },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DeleteRepositoryRequest
 */
export class DeleteRepositoryRequest extends Message<DeleteRepositoryRequest> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeleteRepositoryRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeleteRepositoryResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DeleteRepositoryByFullNameRequest
 */
export class DeleteRepositoryByFullNameRequest extends Message<DeleteRepositoryByFullNameRequest> {
  /**
   * @generated from field: string full_name = 1;
   */
  fullName = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeleteRepositoryByFullNameRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "full_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeleteRepositoryByFullNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DeprecateRepositoryByNameRequest
 */
export class DeprecateRepositoryByNameRequest extends Message<DeprecateRepositoryByNameRequest> {
  /**
   * @generated from field: string owner_name = 1;
   */
  ownerName = "";

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

  /**
   * A message shown along with the deprecation warning for this repository.
   * It must be a utf8 encoded string containing 256 or fewer characters.
   *
   * @generated from field: string deprecation_message = 3;
   */
  deprecationMessage = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeprecateRepositoryByNameRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "owner_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "repository_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "deprecation_message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DeprecateRepositoryByNameResponse
 */
export class DeprecateRepositoryByNameResponse extends Message<DeprecateRepositoryByNameResponse> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Repository repository = 1;
   */
  repository?: Repository;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DeprecateRepositoryByNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository", kind: "message", T: Repository },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UndeprecateRepositoryByNameRequest
 */
export class UndeprecateRepositoryByNameRequest extends Message<UndeprecateRepositoryByNameRequest> {
  /**
   * @generated from field: string owner_name = 1;
   */
  ownerName = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.UndeprecateRepositoryByNameRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "owner_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "repository_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UndeprecateRepositoryByNameResponse
 */
export class UndeprecateRepositoryByNameResponse extends Message<UndeprecateRepositoryByNameResponse> {
  /**
   * @generated from field: buf.alpha.registry.v1alpha1.Repository repository = 1;
   */
  repository?: Repository;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.UndeprecateRepositoryByNameResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository", kind: "message", T: Repository },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.SetRepositoryContributorRequest
 */
export class SetRepositoryContributorRequest extends Message<SetRepositoryContributorRequest> {
  /**
   * The ID of the repository for which the user's role will be set.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

  /**
   * The ID of the user whose role will be set.
   *
   * @generated from field: string user_id = 2;
   */
  userId = "";

  /**
   * The role to assign to the user.
   * Setting UNSPECIFIED means removing the user's role.
   *
   * @generated from field: buf.alpha.registry.v1alpha1.RepositoryRole repository_role = 3;
   */
  repositoryRole = RepositoryRole.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.SetRepositoryContributorRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "user_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "repository_role", kind: "enum", T: proto3.getEnumType(RepositoryRole) },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.SetRepositoryContributorResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoryContributorsRequest
 */
export class ListRepositoryContributorsRequest extends Message<ListRepositoryContributorsRequest> {
  /**
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

  /**
   * The first page is returned if this is empty.
   *
   * @generated from field: string page_token = 3;
   */
  pageToken = "";

  /**
   * @generated from field: bool reverse = 4;
   */
  reverse = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoryContributorsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "page_size", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
    { no: 3, name: "page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListRepositoryContributorsResponse
 */
export class ListRepositoryContributorsResponse extends Message<ListRepositoryContributorsResponse> {
  /**
   * @generated from field: repeated buf.alpha.registry.v1alpha1.RepositoryContributor users = 1;
   */
  users: RepositoryContributor[] = [];

  /**
   * There are no more pages if this is empty.
   *
   * @generated from field: string next_page_token = 2;
   */
  nextPageToken = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListRepositoryContributorsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "users", kind: "message", T: RepositoryContributor, repeated: true },
    { no: 2, name: "next_page_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositorySettingsRequest
 */
export class GetRepositorySettingsRequest extends Message<GetRepositorySettingsRequest> {
  /**
   * The ID of the repository for which to get the settings.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositorySettingsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "repository_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.GetRepositorySettingsResponse
 */
export class GetRepositorySettingsResponse extends Message<GetRepositorySettingsResponse> {
  /**
   * The number of outside contributors in the repository,
   * excluding owning-organization's members that have an explicit role.
   *
   * @generated from field: uint32 contributors_count = 1;
   */
  contributorsCount = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.GetRepositorySettingsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "contributors_count", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
  ]);

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

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

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

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