display_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.8.0 with parameter "ts_nocheck=false,target=ts"
// @generated from file buf/alpha/registry/v1alpha1/display.proto (package buf.alpha.registry.v1alpha1, syntax proto3)
/* eslint-disable */

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayOrganizationElementsRequest
 */
export class DisplayOrganizationElementsRequest extends Message<DisplayOrganizationElementsRequest> {
  /**
   * The ID of the organization for which to check
   * which elements should be displayed.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayOrganizationElementsResponse
 */
export class DisplayOrganizationElementsResponse extends Message<DisplayOrganizationElementsResponse> {
  /**
   * Display create organization repository element if true.
   *
   * @generated from field: bool create_repository = 1;
   */
  createRepository = false;

  /**
   * Display create organization plugin element if true.
   *
   * @generated from field: bool create_plugin = 2;
   */
  createPlugin = false;

  /**
   * Display create organization template element if true.
   *
   * @generated from field: bool create_template = 3;
   */
  createTemplate = false;

  /**
   * Display organization settings element if true.
   *
   * @generated from field: bool settings = 4;
   */
  settings = false;

  /**
   * Display update organization settings element if true.
   *
   * @generated from field: bool update_settings = 5;
   */
  updateSettings = false;

  /**
   * Display delete organization element if true.
   *
   * @generated from field: bool delete = 6;
   */
  delete = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DisplayOrganizationElementsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "create_repository", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "create_plugin", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "create_template", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "settings", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 5, name: "update_settings", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 6, name: "delete", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayRepositoryElementsRequest
 */
export class DisplayRepositoryElementsRequest extends Message<DisplayRepositoryElementsRequest> {
  /**
   * The ID of the repository for which to check
   * which elements should be displayed.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DisplayRepositoryElementsRequest";
  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>): DisplayRepositoryElementsRequest {
    return new DisplayRepositoryElementsRequest().fromBinary(bytes, options);
  }

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayRepositoryElementsResponse
 */
export class DisplayRepositoryElementsResponse extends Message<DisplayRepositoryElementsResponse> {
  /**
   * Display repository settings element if true.
   *
   * @generated from field: bool settings = 1;
   */
  settings = false;

  /**
   * Display delete repository element if true.
   *
   * @generated from field: bool delete = 2;
   */
  delete = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DisplayRepositoryElementsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "settings", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "delete", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayPluginElementsRequest
 */
export class DisplayPluginElementsRequest extends Message<DisplayPluginElementsRequest> {
  /**
   * The ID of the plugin for which to check
   * which elements should be displayed.
   *
   * @generated from field: string plugin_id = 1;
   */
  pluginId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayPluginElementsResponse
 */
export class DisplayPluginElementsResponse extends Message<DisplayPluginElementsResponse> {
  /**
   * Display create plugin version element if true.
   *
   * @generated from field: bool create_version = 1;
   */
  createVersion = false;

  /**
   * Display plugin settings element if true.
   *
   * @generated from field: bool settings = 2;
   */
  settings = false;

  /**
   * Display delete plugin element if true.
   *
   * @generated from field: bool delete = 3;
   */
  delete = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DisplayPluginElementsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "create_version", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "settings", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "delete", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayTemplateElementsRequest
 */
export class DisplayTemplateElementsRequest extends Message<DisplayTemplateElementsRequest> {
  /**
   * The ID of the template for which to check
   * which elements should be displayed.
   *
   * @generated from field: string template_id = 1;
   */
  templateId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayTemplateElementsResponse
 */
export class DisplayTemplateElementsResponse extends Message<DisplayTemplateElementsResponse> {
  /**
   * Display create template version element if true.
   *
   * @generated from field: bool create_version = 1;
   */
  createVersion = false;

  /**
   * Display template settings element if true.
   *
   * @generated from field: bool settings = 2;
   */
  settings = false;

  /**
   * Display delete template element if true.
   *
   * @generated from field: bool delete = 3;
   */
  delete = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.DisplayTemplateElementsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "create_version", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "settings", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "delete", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayUserElementsResponse
 */
export class DisplayUserElementsResponse extends Message<DisplayUserElementsResponse> {
  /**
   * Display delete user element if true.
   *
   * @generated from field: bool delete = 1;
   */
  delete = false;

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.DisplayServerElementsResponse
 */
export class DisplayServerElementsResponse extends Message<DisplayServerElementsResponse> {
  /**
   * Display server admin panel element if true.
   *
   * @generated from field: bool admin_panel = 1;
   */
  adminPanel = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableRepositoryRolesRequest
 */
export class ListManageableRepositoryRolesRequest extends Message<ListManageableRepositoryRolesRequest> {
  /**
   * The ID of the repository for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableRepositoryRolesRequest";
  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>): ListManageableRepositoryRolesRequest {
    return new ListManageableRepositoryRolesRequest().fromBinary(bytes, options);
  }

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableRepositoryRolesResponse
 */
export class ListManageableRepositoryRolesResponse extends Message<ListManageableRepositoryRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.RepositoryRole roles = 1;
   */
  roles: RepositoryRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableRepositoryRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(RepositoryRole), repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserRepositoryRolesRequest
 */
export class ListManageableUserRepositoryRolesRequest extends Message<ListManageableUserRepositoryRolesRequest> {
  /**
   * The ID of the repository for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

  /**
   * The ID of the target user for which to check
   * which roles are manageable.
   *
   * @generated from field: string user_id = 2;
   */
  userId = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableUserRepositoryRolesRequest";
  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 */ },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserRepositoryRolesResponse
 */
export class ListManageableUserRepositoryRolesResponse extends Message<ListManageableUserRepositoryRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.RepositoryRole roles = 1;
   */
  roles: RepositoryRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableUserRepositoryRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(RepositoryRole), repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageablePluginRolesRequest
 */
export class ListManageablePluginRolesRequest extends Message<ListManageablePluginRolesRequest> {
  /**
   * The ID of the plugin for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string plugin_id = 1;
   */
  pluginId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageablePluginRolesResponse
 */
export class ListManageablePluginRolesResponse extends Message<ListManageablePluginRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.PluginRole roles = 1;
   */
  roles: PluginRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageablePluginRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(PluginRole), repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserPluginRolesRequest
 */
export class ListManageableUserPluginRolesRequest extends Message<ListManageableUserPluginRolesRequest> {
  /**
   * The ID of the plugin for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string plugin_id = 1;
   */
  pluginId = "";

  /**
   * The ID of the target user for which to check
   * which roles are manageable.
   *
   * @generated from field: string user_id = 2;
   */
  userId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserPluginRolesResponse
 */
export class ListManageableUserPluginRolesResponse extends Message<ListManageableUserPluginRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.PluginRole roles = 1;
   */
  roles: PluginRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableUserPluginRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(PluginRole), repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableTemplateRolesRequest
 */
export class ListManageableTemplateRolesRequest extends Message<ListManageableTemplateRolesRequest> {
  /**
   * The ID of the template for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string template_id = 1;
   */
  templateId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableTemplateRolesResponse
 */
export class ListManageableTemplateRolesResponse extends Message<ListManageableTemplateRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.TemplateRole roles = 1;
   */
  roles: TemplateRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableTemplateRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(TemplateRole), repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserTemplateRolesRequest
 */
export class ListManageableUserTemplateRolesRequest extends Message<ListManageableUserTemplateRolesRequest> {
  /**
   * The ID of the template for which to check
   * which roles should be displayed as manageable.
   *
   * @generated from field: string template_id = 1;
   */
  templateId = "";

  /**
   * The ID of the target user for which to check
   * which roles are manageable.
   *
   * @generated from field: string user_id = 2;
   */
  userId = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.ListManageableUserTemplateRolesResponse
 */
export class ListManageableUserTemplateRolesResponse extends Message<ListManageableUserTemplateRolesResponse> {
  /**
   * The list of roles that should be displayed
   * to the user as manageable.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.TemplateRole roles = 1;
   */
  roles: TemplateRole[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "buf.alpha.registry.v1alpha1.ListManageableUserTemplateRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "enum", T: proto3.getEnumType(TemplateRole), repeated: true },
  ]);

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

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

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

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