authz_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/authz.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 { OrganizationRole, PluginRole, RepositoryRole, TemplateRole } from "./role_pb.js";

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationRepositoryRequest
 */
export class UserCanCreateOrganizationRepositoryRequest extends Message<UserCanCreateOrganizationRepositoryRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationRepositoryResponse
 */
export class UserCanCreateOrganizationRepositoryResponse extends Message<UserCanCreateOrganizationRepositoryResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeRepositorySettingsRequest
 */
export class UserCanSeeRepositorySettingsRequest extends Message<UserCanSeeRepositorySettingsRequest> {
  /**
   * The ID of the repository for which to check
   * whether the user is authorized.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeRepositorySettingsResponse
 */
export class UserCanSeeRepositorySettingsResponse extends Message<UserCanSeeRepositorySettingsResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeOrganizationSettingsRequest
 */
export class UserCanSeeOrganizationSettingsRequest extends Message<UserCanSeeOrganizationSettingsRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeOrganizationSettingsResponse
 */
export class UserCanSeeOrganizationSettingsResponse extends Message<UserCanSeeOrganizationSettingsResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanReadPluginRequest
 */
export class UserCanReadPluginRequest extends Message<UserCanReadPluginRequest> {
  /**
   * The owner of the plugin.
   *
   * @generated from field: string owner = 1;
   */
  owner = "";

  /**
   * The name of the plugin.
   *
   * @generated from field: string name = 2;
   */
  name = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanReadPluginResponse
 */
export class UserCanReadPluginResponse extends Message<UserCanReadPluginResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreatePluginVersionRequest
 */
export class UserCanCreatePluginVersionRequest extends Message<UserCanCreatePluginVersionRequest> {
  /**
   * The owner of the plugin.
   *
   * @generated from field: string owner = 1;
   */
  owner = "";

  /**
   * The name of the plugin.
   *
   * @generated from field: string name = 2;
   */
  name = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreatePluginVersionResponse
 */
export class UserCanCreatePluginVersionResponse extends Message<UserCanCreatePluginVersionResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateTemplateVersionRequest
 */
export class UserCanCreateTemplateVersionRequest extends Message<UserCanCreateTemplateVersionRequest> {
  /**
   * The owner of the template.
   *
   * @generated from field: string owner = 1;
   */
  owner = "";

  /**
   * The name of the template.
   *
   * @generated from field: string name = 2;
   */
  name = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateTemplateVersionResponse
 */
export class UserCanCreateTemplateVersionResponse extends Message<UserCanCreateTemplateVersionResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationPluginRequest
 */
export class UserCanCreateOrganizationPluginRequest extends Message<UserCanCreateOrganizationPluginRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationPluginResponse
 */
export class UserCanCreateOrganizationPluginResponse extends Message<UserCanCreateOrganizationPluginResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationTemplateRequest
 */
export class UserCanCreateOrganizationTemplateRequest extends Message<UserCanCreateOrganizationTemplateRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanCreateOrganizationTemplateResponse
 */
export class UserCanCreateOrganizationTemplateResponse extends Message<UserCanCreateOrganizationTemplateResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeePluginSettingsRequest
 */
export class UserCanSeePluginSettingsRequest extends Message<UserCanSeePluginSettingsRequest> {
  /**
   * The owner of the plugin.
   *
   * @generated from field: string owner = 1;
   */
  owner = "";

  /**
   * The name of the plugin.
   *
   * @generated from field: string name = 2;
   */
  name = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeePluginSettingsResponse
 */
export class UserCanSeePluginSettingsResponse extends Message<UserCanSeePluginSettingsResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeTemplateSettingsRequest
 */
export class UserCanSeeTemplateSettingsRequest extends Message<UserCanSeeTemplateSettingsRequest> {
  /**
   * The owner of the template.
   *
   * @generated from field: string owner = 1;
   */
  owner = "";

  /**
   * The name of the template.
   *
   * @generated from field: string name = 2;
   */
  name = "";

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeTemplateSettingsResponse
 */
export class UserCanSeeTemplateSettingsResponse extends Message<UserCanSeeTemplateSettingsResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanAddOrganizationMemberRequest
 */
export class UserCanAddOrganizationMemberRequest extends Message<UserCanAddOrganizationMemberRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanAddOrganizationMemberResponse
 */
export class UserCanAddOrganizationMemberResponse extends Message<UserCanAddOrganizationMemberResponse> {
  /**
   * The list of roles that the user is authorized to add, empty list means the user is
   * not authorized to add any members.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.OrganizationRole authorized_roles = 1;
   */
  authorizedRoles: OrganizationRole[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanUpdateOrganizationMemberRequest
 */
export class UserCanUpdateOrganizationMemberRequest extends Message<UserCanUpdateOrganizationMemberRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanUpdateOrganizationMemberResponse
 */
export class UserCanUpdateOrganizationMemberResponse extends Message<UserCanUpdateOrganizationMemberResponse> {
  /**
   * The list of roles that the user is authorized to update (from and to), empty list means the user is
   * not authorized to update any members' role.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.OrganizationRole authorized_roles = 1;
   */
  authorizedRoles: OrganizationRole[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanRemoveOrganizationMemberRequest
 */
export class UserCanRemoveOrganizationMemberRequest extends Message<UserCanRemoveOrganizationMemberRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanRemoveOrganizationMemberResponse
 */
export class UserCanRemoveOrganizationMemberResponse extends Message<UserCanRemoveOrganizationMemberResponse> {
  /**
   * The list of roles that the user is authorized to remove, empty list means the user is
   * not authorized to remove any members.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.OrganizationRole authorized_roles = 1;
   */
  authorizedRoles: OrganizationRole[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteOrganizationRequest
 */
export class UserCanDeleteOrganizationRequest extends Message<UserCanDeleteOrganizationRequest> {
  /**
   * The ID of the organization for which to check
   * whether the user is authorized.
   *
   * @generated from field: string organization_id = 1;
   */
  organizationId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteOrganizationResponse
 */
export class UserCanDeleteOrganizationResponse extends Message<UserCanDeleteOrganizationResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteRepositoryRequest
 */
export class UserCanDeleteRepositoryRequest extends Message<UserCanDeleteRepositoryRequest> {
  /**
   * The ID of the repository for which to check
   * whether the user is authorized.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteRepositoryResponse
 */
export class UserCanDeleteRepositoryResponse extends Message<UserCanDeleteRepositoryResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteTemplateRequest
 */
export class UserCanDeleteTemplateRequest extends Message<UserCanDeleteTemplateRequest> {
  /**
   * The ID of the template for which to check
   * whether the user is authorized.
   *
   * @generated from field: string template_id = 1;
   */
  templateId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteTemplateResponse
 */
export class UserCanDeleteTemplateResponse extends Message<UserCanDeleteTemplateResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeletePluginRequest
 */
export class UserCanDeletePluginRequest extends Message<UserCanDeletePluginRequest> {
  /**
   * The ID of the plugin for which to check
   * whether the user is authorized.
   *
   * @generated from field: string plugin_id = 1;
   */
  pluginId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeletePluginResponse
 */
export class UserCanDeletePluginResponse extends Message<UserCanDeletePluginResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanDeleteUserResponse
 */
export class UserCanDeleteUserResponse extends Message<UserCanDeleteUserResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanSeeServerAdminPanelResponse
 */
export class UserCanSeeServerAdminPanelResponse extends Message<UserCanSeeServerAdminPanelResponse> {
  /**
   * @generated from field: bool authorized = 1;
   */
  authorized = false;

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManageRepositoryContributorsRequest
 */
export class UserCanManageRepositoryContributorsRequest extends Message<UserCanManageRepositoryContributorsRequest> {
  /**
   * The ID of the repository for which to check
   * whether the user is authorized.
   *
   * @generated from field: string repository_id = 1;
   */
  repositoryId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManageRepositoryContributorsResponse
 */
export class UserCanManageRepositoryContributorsResponse extends Message<UserCanManageRepositoryContributorsResponse> {
  /**
   * The list of roles that the user is authorized to manage, empty list means the user is
   * not authorized to manage any contributors.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.RepositoryRole authorized_roles = 1;
   */
  authorizedRoles: RepositoryRole[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManagePluginContributorsRequest
 */
export class UserCanManagePluginContributorsRequest extends Message<UserCanManagePluginContributorsRequest> {
  /**
   * The ID of the plugin for which to check
   * whether the user is authorized.
   *
   * @generated from field: string plugin_id = 1;
   */
  pluginId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManagePluginContributorsResponse
 */
export class UserCanManagePluginContributorsResponse extends Message<UserCanManagePluginContributorsResponse> {
  /**
   * The list of roles that the user is authorized to manage, empty list means the user is
   * not authorized to manage any contributors.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.PluginRole authorized_roles = 1;
   */
  authorizedRoles: PluginRole[] = [];

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

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManageTemplateContributorsRequest
 */
export class UserCanManageTemplateContributorsRequest extends Message<UserCanManageTemplateContributorsRequest> {
  /**
   * The ID of the template for which to check
   * whether the user is authorized.
   *
   * @generated from field: string template_id = 1;
   */
  templateId = "";

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

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

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

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

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

/**
 * @generated from message buf.alpha.registry.v1alpha1.UserCanManageTemplateContributorsResponse
 */
export class UserCanManageTemplateContributorsResponse extends Message<UserCanManageTemplateContributorsResponse> {
  /**
   * The list of roles that the user is authorized to manage, empty list means the user is
   * not authorized to manage any contributors.
   *
   * @generated from field: repeated buf.alpha.registry.v1alpha1.TemplateRole authorized_roles = 1;
   */
  authorizedRoles: TemplateRole[] = [];

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

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

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

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

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

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