// @generated by protoc-gen-es v1.10.0 with parameter "target=ts,import_extension=none"
// @generated from file svc/organization/v1/service.proto (package svc.organization.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Environment } from "../../../types/v1/environment_pb";
import { Cursor } from "../../../types/v1/cursor_pb";
import { Product } from "../../../types/v1/product_pb";
import { User } from "../../../types/v1/user_pb";
import { Subscription } from "../../../types/v1/subscription_pb";
import { PaymentMethod } from "../../../types/v1/payment_method_pb";

/**
 * @generated from message svc.organization.v1.CreateEnvironmentRequest
 */
export class CreateEnvironmentRequest extends Message<CreateEnvironmentRequest> {
  /**
   * @generated from field: string environment_name = 1;
   */
  environmentName = "";

  /**
   * @generated from oneof svc.organization.v1.CreateEnvironmentRequest.payment
   */
  payment: {
    /**
     * @generated from field: svc.organization.v1.CreateEnvironmentRequest.Stripe stripe = 201;
     */
    value: CreateEnvironmentRequest_Stripe;
    case: "stripe";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateEnvironmentRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "environment_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 201, name: "stripe", kind: "message", T: CreateEnvironmentRequest_Stripe, oneof: "payment" },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateEnvironmentRequest.Stripe
 */
export class CreateEnvironmentRequest_Stripe extends Message<CreateEnvironmentRequest_Stripe> {
  /**
   * @generated from field: string confirmation_token = 1;
   */
  confirmationToken = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateEnvironmentRequest.Stripe";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "confirmation_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "price_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateEnvironmentResponse
 */
export class CreateEnvironmentResponse extends Message<CreateEnvironmentResponse> {
  /**
   * @generated from field: types.v1.Environment environment = 1;
   */
  environment?: Environment;

  /**
   * @generated from oneof svc.organization.v1.CreateEnvironmentResponse.payment
   */
  payment: {
    /**
     * @generated from field: svc.organization.v1.CreateEnvironmentResponse.Stripe stripe = 201;
     */
    value: CreateEnvironmentResponse_Stripe;
    case: "stripe";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateEnvironmentResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "environment", kind: "message", T: Environment },
    { no: 201, name: "stripe", kind: "message", T: CreateEnvironmentResponse_Stripe, oneof: "payment" },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateEnvironmentResponse.Stripe
 */
export class CreateEnvironmentResponse_Stripe extends Message<CreateEnvironmentResponse_Stripe> {
  /**
   * @generated from field: string status = 1;
   */
  status = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateEnvironmentResponse.Stripe";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "client_secret", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.GetEnvironmentRequest
 */
export class GetEnvironmentRequest extends Message<GetEnvironmentRequest> {
  /**
   * @generated from oneof svc.organization.v1.GetEnvironmentRequest.by
   */
  by: {
    /**
     * @generated from field: int64 id = 1;
     */
    value: bigint;
    case: "id";
  } | {
    /**
     * @generated from field: string name = 2;
     */
    value: string;
    case: "name";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.GetEnvironmentRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 3 /* ScalarType.INT64 */, oneof: "by" },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "by" },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.GetEnvironmentResponse
 */
export class GetEnvironmentResponse extends Message<GetEnvironmentResponse> {
  /**
   * @generated from field: types.v1.Environment environment = 1;
   */
  environment?: Environment;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.GetEnvironmentResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "environment", kind: "message", T: Environment },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListEnvironmentRequest
 */
export class ListEnvironmentRequest extends Message<ListEnvironmentRequest> {
  /**
   * @generated from field: types.v1.Cursor cursor = 1;
   */
  cursor?: Cursor;

  /**
   * @generated from field: int32 limit = 2;
   */
  limit = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListEnvironmentRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "cursor", kind: "message", T: Cursor },
    { no: 2, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListEnvironmentResponse
 */
export class ListEnvironmentResponse extends Message<ListEnvironmentResponse> {
  /**
   * @generated from field: types.v1.Cursor next = 1;
   */
  next?: Cursor;

  /**
   * @generated from field: repeated svc.organization.v1.ListEnvironmentResponse.ListItem items = 2;
   */
  items: ListEnvironmentResponse_ListItem[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListEnvironmentResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "next", kind: "message", T: Cursor },
    { no: 2, name: "items", kind: "message", T: ListEnvironmentResponse_ListItem, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListEnvironmentResponse.ListItem
 */
export class ListEnvironmentResponse_ListItem extends Message<ListEnvironmentResponse_ListItem> {
  /**
   * @generated from field: types.v1.Environment environment = 1;
   */
  environment?: Environment;

  /**
   * @generated from field: types.v1.Product product = 2;
   */
  product?: Product;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListEnvironmentResponse.ListItem";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "environment", kind: "message", T: Environment },
    { no: 2, name: "product", kind: "message", T: Product },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListUserRequest
 */
export class ListUserRequest extends Message<ListUserRequest> {
  /**
   * @generated from field: types.v1.Cursor cursor = 1;
   */
  cursor?: Cursor;

  /**
   * @generated from field: int32 limit = 2;
   */
  limit = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListUserRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "cursor", kind: "message", T: Cursor },
    { no: 2, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListUserResponse
 */
export class ListUserResponse extends Message<ListUserResponse> {
  /**
   * @generated from field: types.v1.Cursor next = 1;
   */
  next?: Cursor;

  /**
   * @generated from field: repeated svc.organization.v1.ListUserResponse.ListItem items = 2;
   */
  items: ListUserResponse_ListItem[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListUserResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "next", kind: "message", T: Cursor },
    { no: 2, name: "items", kind: "message", T: ListUserResponse_ListItem, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListUserResponse.ListItem
 */
export class ListUserResponse_ListItem extends Message<ListUserResponse_ListItem> {
  /**
   * @generated from field: types.v1.User user = 1;
   */
  user?: User;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListUserResponse.ListItem";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "user", kind: "message", T: User },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.InviteUserRequest
 */
export class InviteUserRequest extends Message<InviteUserRequest> {
  /**
   * @generated from field: int64 user_email = 1;
   */
  userEmail = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.InviteUserRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "user_email", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.InviteUserResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.RevokeUserRequest
 */
export class RevokeUserRequest extends Message<RevokeUserRequest> {
  /**
   * @generated from field: int64 user_id = 1;
   */
  userId = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.RevokeUserRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "user_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.RevokeUserResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateAddonSubscriptionRequest
 */
export class CreateAddonSubscriptionRequest extends Message<CreateAddonSubscriptionRequest> {
  /**
   * @generated from oneof svc.organization.v1.CreateAddonSubscriptionRequest.payment
   */
  payment: {
    /**
     * @generated from field: svc.organization.v1.CreateAddonSubscriptionRequest.Stripe stripe = 201;
     */
    value: CreateAddonSubscriptionRequest_Stripe;
    case: "stripe";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateAddonSubscriptionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 201, name: "stripe", kind: "message", T: CreateAddonSubscriptionRequest_Stripe, oneof: "payment" },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateAddonSubscriptionRequest.Stripe
 */
export class CreateAddonSubscriptionRequest_Stripe extends Message<CreateAddonSubscriptionRequest_Stripe> {
  /**
   * @generated from field: string confirmation_token = 1;
   */
  confirmationToken = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateAddonSubscriptionRequest.Stripe";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "confirmation_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "price_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateAddonSubscriptionResponse
 */
export class CreateAddonSubscriptionResponse extends Message<CreateAddonSubscriptionResponse> {
  /**
   * @generated from oneof svc.organization.v1.CreateAddonSubscriptionResponse.payment
   */
  payment: {
    /**
     * @generated from field: svc.organization.v1.CreateAddonSubscriptionResponse.Stripe stripe = 201;
     */
    value: CreateAddonSubscriptionResponse_Stripe;
    case: "stripe";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateAddonSubscriptionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 201, name: "stripe", kind: "message", T: CreateAddonSubscriptionResponse_Stripe, oneof: "payment" },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateAddonSubscriptionResponse.Stripe
 */
export class CreateAddonSubscriptionResponse_Stripe extends Message<CreateAddonSubscriptionResponse_Stripe> {
  /**
   * @generated from field: string status = 1;
   */
  status = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateAddonSubscriptionResponse.Stripe";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "client_secret", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListAddonSubscriptionRequest
 */
export class ListAddonSubscriptionRequest extends Message<ListAddonSubscriptionRequest> {
  /**
   * @generated from field: types.v1.Cursor cursor = 1;
   */
  cursor?: Cursor;

  /**
   * @generated from field: int32 limit = 2;
   */
  limit = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListAddonSubscriptionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "cursor", kind: "message", T: Cursor },
    { no: 2, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListAddonSubscriptionResponse
 */
export class ListAddonSubscriptionResponse extends Message<ListAddonSubscriptionResponse> {
  /**
   * @generated from field: types.v1.Cursor next = 1;
   */
  next?: Cursor;

  /**
   * @generated from field: repeated svc.organization.v1.ListAddonSubscriptionResponse.ListItem items = 2;
   */
  items: ListAddonSubscriptionResponse_ListItem[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListAddonSubscriptionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "next", kind: "message", T: Cursor },
    { no: 2, name: "items", kind: "message", T: ListAddonSubscriptionResponse_ListItem, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListAddonSubscriptionResponse.ListItem
 */
export class ListAddonSubscriptionResponse_ListItem extends Message<ListAddonSubscriptionResponse_ListItem> {
  /**
   * @generated from field: types.v1.Product product = 1;
   */
  product?: Product;

  /**
   * @generated from field: types.v1.Subscription subscription = 2;
   */
  subscription?: Subscription;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListAddonSubscriptionResponse.ListItem";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "product", kind: "message", T: Product },
    { no: 2, name: "subscription", kind: "message", T: Subscription },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.RemoveAddonSubscriptionRequest
 */
export class RemoveAddonSubscriptionRequest extends Message<RemoveAddonSubscriptionRequest> {
  /**
   * @generated from field: types.v1.Product product = 1;
   */
  product?: Product;

  /**
   * @generated from field: optional svc.organization.v1.RemoveAddonSubscriptionRequest.Reason cancel_reason = 2;
   */
  cancelReason?: RemoveAddonSubscriptionRequest_Reason;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.RemoveAddonSubscriptionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "product", kind: "message", T: Product },
    { no: 2, name: "cancel_reason", kind: "message", T: RemoveAddonSubscriptionRequest_Reason, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.RemoveAddonSubscriptionRequest.Reason
 */
export class RemoveAddonSubscriptionRequest_Reason extends Message<RemoveAddonSubscriptionRequest_Reason> {
  /**
   * @generated from field: string comment = 1;
   */
  comment = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.RemoveAddonSubscriptionRequest.Reason";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "comment", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "feedback", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.RemoveAddonSubscriptionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.GetStripePublishableKeyRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.GetStripePublishableKeyResponse
 */
export class GetStripePublishableKeyResponse extends Message<GetStripePublishableKeyResponse> {
  /**
   * @generated from field: string stripe_publishable_key = 2;
   */
  stripePublishableKey = "";

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

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

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

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

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

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

/**
 * @generated from message svc.organization.v1.GetStripeBillingPortalRequest
 */
export class GetStripeBillingPortalRequest extends Message<GetStripeBillingPortalRequest> {
  /**
   * @generated from field: string return_to_url = 1;
   */
  returnToUrl = "";

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

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

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

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

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

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

/**
 * @generated from message svc.organization.v1.GetStripeBillingPortalResponse
 */
export class GetStripeBillingPortalResponse extends Message<GetStripeBillingPortalResponse> {
  /**
   * @generated from field: string return_to_url = 1;
   */
  returnToUrl = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.GetStripeBillingPortalResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "return_to_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "portal_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.CreateStripeCustomerSessionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.CreateStripeCustomerSessionResponse
 */
export class CreateStripeCustomerSessionResponse extends Message<CreateStripeCustomerSessionResponse> {
  /**
   * @generated from field: string customer_session_client_secret = 1;
   */
  customerSessionClientSecret = "";

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

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

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListPaymentMethodRequest
 */
export class ListPaymentMethodRequest extends Message<ListPaymentMethodRequest> {
  /**
   * @generated from field: types.v1.Cursor cursor = 1;
   */
  cursor?: Cursor;

  /**
   * @generated from field: int32 limit = 2;
   */
  limit = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListPaymentMethodRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "cursor", kind: "message", T: Cursor },
    { no: 2, name: "limit", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListPaymentMethodResponse
 */
export class ListPaymentMethodResponse extends Message<ListPaymentMethodResponse> {
  /**
   * @generated from field: types.v1.Cursor next = 1;
   */
  next?: Cursor;

  /**
   * @generated from field: repeated svc.organization.v1.ListPaymentMethodResponse.ListItem items = 2;
   */
  items: ListPaymentMethodResponse_ListItem[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListPaymentMethodResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "next", kind: "message", T: Cursor },
    { no: 2, name: "items", kind: "message", T: ListPaymentMethodResponse_ListItem, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message svc.organization.v1.ListPaymentMethodResponse.ListItem
 */
export class ListPaymentMethodResponse_ListItem extends Message<ListPaymentMethodResponse_ListItem> {
  /**
   * @generated from field: types.v1.PaymentMethod payment_method = 1;
   */
  paymentMethod?: PaymentMethod;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "svc.organization.v1.ListPaymentMethodResponse.ListItem";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "payment_method", kind: "message", T: PaymentMethod },
  ]);

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

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

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

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

