import * as jspb from 'google-protobuf'

import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/struct_pb'; // proto import: "google/protobuf/struct.proto"


export class Permission extends jspb.Message {
  getName(): string;
  setName(value: string): Permission;

  getApplicationsList(): Array<string>;
  setApplicationsList(value: Array<string>): Permission;
  clearApplicationsList(): Permission;
  addApplications(value: string, index?: number): Permission;

  getNodeIdentitiesList(): Array<string>;
  setNodeIdentitiesList(value: Array<string>): Permission;
  clearNodeIdentitiesList(): Permission;
  addNodeIdentities(value: string, index?: number): Permission;

  getAccountsList(): Array<string>;
  setAccountsList(value: Array<string>): Permission;
  clearAccountsList(): Permission;
  addAccounts(value: string, index?: number): Permission;

  getGroupsList(): Array<string>;
  setGroupsList(value: Array<string>): Permission;
  clearGroupsList(): Permission;
  addGroups(value: string, index?: number): Permission;

  getOrganizationsList(): Array<string>;
  setOrganizationsList(value: Array<string>): Permission;
  clearOrganizationsList(): Permission;
  addOrganizations(value: string, index?: number): Permission;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Permission.AsObject;
  static toObject(includeInstance: boolean, msg: Permission): Permission.AsObject;
  static serializeBinaryToWriter(message: Permission, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Permission;
  static deserializeBinaryFromReader(message: Permission, reader: jspb.BinaryReader): Permission;
}

export namespace Permission {
  export type AsObject = {
    name: string,
    applicationsList: Array<string>,
    nodeIdentitiesList: Array<string>,
    accountsList: Array<string>,
    groupsList: Array<string>,
    organizationsList: Array<string>,
  }
}

export class Permissions extends jspb.Message {
  getPath(): string;
  setPath(value: string): Permissions;

  getResourceType(): string;
  setResourceType(value: string): Permissions;

  getOwners(): Permission | undefined;
  setOwners(value?: Permission): Permissions;
  hasOwners(): boolean;
  clearOwners(): Permissions;

  getAllowedList(): Array<Permission>;
  setAllowedList(value: Array<Permission>): Permissions;
  clearAllowedList(): Permissions;
  addAllowed(value?: Permission, index?: number): Permission;

  getDeniedList(): Array<Permission>;
  setDeniedList(value: Array<Permission>): Permissions;
  clearDeniedList(): Permissions;
  addDenied(value?: Permission, index?: number): Permission;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Permissions.AsObject;
  static toObject(includeInstance: boolean, msg: Permissions): Permissions.AsObject;
  static serializeBinaryToWriter(message: Permissions, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Permissions;
  static deserializeBinaryFromReader(message: Permissions, reader: jspb.BinaryReader): Permissions;
}

export namespace Permissions {
  export type AsObject = {
    path: string,
    resourceType: string,
    owners?: Permission.AsObject,
    allowedList: Array<Permission.AsObject>,
    deniedList: Array<Permission.AsObject>,
  }
}

export class GetResourcePermissionsRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): GetResourcePermissionsRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsRqst): GetResourcePermissionsRqst.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsRqst;
  static deserializeBinaryFromReader(message: GetResourcePermissionsRqst, reader: jspb.BinaryReader): GetResourcePermissionsRqst;
}

export namespace GetResourcePermissionsRqst {
  export type AsObject = {
    path: string,
  }
}

export class GetResourcePermissionsRsp extends jspb.Message {
  getPermissions(): Permissions | undefined;
  setPermissions(value?: Permissions): GetResourcePermissionsRsp;
  hasPermissions(): boolean;
  clearPermissions(): GetResourcePermissionsRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsRsp): GetResourcePermissionsRsp.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsRsp;
  static deserializeBinaryFromReader(message: GetResourcePermissionsRsp, reader: jspb.BinaryReader): GetResourcePermissionsRsp;
}

export namespace GetResourcePermissionsRsp {
  export type AsObject = {
    permissions?: Permissions.AsObject,
  }
}

export class GetResourcePermissionsByResourceTypeRqst extends jspb.Message {
  getResourcetype(): string;
  setResourcetype(value: string): GetResourcePermissionsByResourceTypeRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsByResourceTypeRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsByResourceTypeRqst): GetResourcePermissionsByResourceTypeRqst.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsByResourceTypeRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsByResourceTypeRqst;
  static deserializeBinaryFromReader(message: GetResourcePermissionsByResourceTypeRqst, reader: jspb.BinaryReader): GetResourcePermissionsByResourceTypeRqst;
}

export namespace GetResourcePermissionsByResourceTypeRqst {
  export type AsObject = {
    resourcetype: string,
  }
}

export class GetResourcePermissionsByResourceTypeRsp extends jspb.Message {
  getPermissionsList(): Array<Permissions>;
  setPermissionsList(value: Array<Permissions>): GetResourcePermissionsByResourceTypeRsp;
  clearPermissionsList(): GetResourcePermissionsByResourceTypeRsp;
  addPermissions(value?: Permissions, index?: number): Permissions;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsByResourceTypeRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsByResourceTypeRsp): GetResourcePermissionsByResourceTypeRsp.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsByResourceTypeRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsByResourceTypeRsp;
  static deserializeBinaryFromReader(message: GetResourcePermissionsByResourceTypeRsp, reader: jspb.BinaryReader): GetResourcePermissionsByResourceTypeRsp;
}

export namespace GetResourcePermissionsByResourceTypeRsp {
  export type AsObject = {
    permissionsList: Array<Permissions.AsObject>,
  }
}

export class GetResourcePermissionsBySubjectRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): GetResourcePermissionsBySubjectRqst;

  getSubjectType(): SubjectType;
  setSubjectType(value: SubjectType): GetResourcePermissionsBySubjectRqst;

  getResourceType(): string;
  setResourceType(value: string): GetResourcePermissionsBySubjectRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsBySubjectRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsBySubjectRqst): GetResourcePermissionsBySubjectRqst.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsBySubjectRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsBySubjectRqst;
  static deserializeBinaryFromReader(message: GetResourcePermissionsBySubjectRqst, reader: jspb.BinaryReader): GetResourcePermissionsBySubjectRqst;
}

export namespace GetResourcePermissionsBySubjectRqst {
  export type AsObject = {
    subject: string,
    subjectType: SubjectType,
    resourceType: string,
  }
}

export class GetResourcePermissionsBySubjectRsp extends jspb.Message {
  getPermissionsList(): Array<Permissions>;
  setPermissionsList(value: Array<Permissions>): GetResourcePermissionsBySubjectRsp;
  clearPermissionsList(): GetResourcePermissionsBySubjectRsp;
  addPermissions(value?: Permissions, index?: number): Permissions;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionsBySubjectRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionsBySubjectRsp): GetResourcePermissionsBySubjectRsp.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionsBySubjectRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionsBySubjectRsp;
  static deserializeBinaryFromReader(message: GetResourcePermissionsBySubjectRsp, reader: jspb.BinaryReader): GetResourcePermissionsBySubjectRsp;
}

export namespace GetResourcePermissionsBySubjectRsp {
  export type AsObject = {
    permissionsList: Array<Permissions.AsObject>,
  }
}

export class DeleteResourcePermissionsRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): DeleteResourcePermissionsRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteResourcePermissionsRqst.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteResourcePermissionsRqst): DeleteResourcePermissionsRqst.AsObject;
  static serializeBinaryToWriter(message: DeleteResourcePermissionsRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteResourcePermissionsRqst;
  static deserializeBinaryFromReader(message: DeleteResourcePermissionsRqst, reader: jspb.BinaryReader): DeleteResourcePermissionsRqst;
}

export namespace DeleteResourcePermissionsRqst {
  export type AsObject = {
    path: string,
  }
}

export class DeleteResourcePermissionsRsp extends jspb.Message {
  getPermissions(): Permissions | undefined;
  setPermissions(value?: Permissions): DeleteResourcePermissionsRsp;
  hasPermissions(): boolean;
  clearPermissions(): DeleteResourcePermissionsRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteResourcePermissionsRsp.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteResourcePermissionsRsp): DeleteResourcePermissionsRsp.AsObject;
  static serializeBinaryToWriter(message: DeleteResourcePermissionsRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteResourcePermissionsRsp;
  static deserializeBinaryFromReader(message: DeleteResourcePermissionsRsp, reader: jspb.BinaryReader): DeleteResourcePermissionsRsp;
}

export namespace DeleteResourcePermissionsRsp {
  export type AsObject = {
    permissions?: Permissions.AsObject,
  }
}

export class DeleteResourcePermissionRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): DeleteResourcePermissionRqst;

  getName(): string;
  setName(value: string): DeleteResourcePermissionRqst;

  getType(): PermissionType;
  setType(value: PermissionType): DeleteResourcePermissionRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteResourcePermissionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteResourcePermissionRqst): DeleteResourcePermissionRqst.AsObject;
  static serializeBinaryToWriter(message: DeleteResourcePermissionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteResourcePermissionRqst;
  static deserializeBinaryFromReader(message: DeleteResourcePermissionRqst, reader: jspb.BinaryReader): DeleteResourcePermissionRqst;
}

export namespace DeleteResourcePermissionRqst {
  export type AsObject = {
    path: string,
    name: string,
    type: PermissionType,
  }
}

export class DeleteResourcePermissionRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteResourcePermissionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteResourcePermissionRsp): DeleteResourcePermissionRsp.AsObject;
  static serializeBinaryToWriter(message: DeleteResourcePermissionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteResourcePermissionRsp;
  static deserializeBinaryFromReader(message: DeleteResourcePermissionRsp, reader: jspb.BinaryReader): DeleteResourcePermissionRsp;
}

export namespace DeleteResourcePermissionRsp {
  export type AsObject = {
  }
}

export class SetResourcePermissionsRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): SetResourcePermissionsRqst;

  getResourcetype(): string;
  setResourcetype(value: string): SetResourcePermissionsRqst;

  getPermissions(): Permissions | undefined;
  setPermissions(value?: Permissions): SetResourcePermissionsRqst;
  hasPermissions(): boolean;
  clearPermissions(): SetResourcePermissionsRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetResourcePermissionsRqst.AsObject;
  static toObject(includeInstance: boolean, msg: SetResourcePermissionsRqst): SetResourcePermissionsRqst.AsObject;
  static serializeBinaryToWriter(message: SetResourcePermissionsRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetResourcePermissionsRqst;
  static deserializeBinaryFromReader(message: SetResourcePermissionsRqst, reader: jspb.BinaryReader): SetResourcePermissionsRqst;
}

export namespace SetResourcePermissionsRqst {
  export type AsObject = {
    path: string,
    resourcetype: string,
    permissions?: Permissions.AsObject,
  }
}

export class SetResourcePermissionsRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetResourcePermissionsRsp.AsObject;
  static toObject(includeInstance: boolean, msg: SetResourcePermissionsRsp): SetResourcePermissionsRsp.AsObject;
  static serializeBinaryToWriter(message: SetResourcePermissionsRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetResourcePermissionsRsp;
  static deserializeBinaryFromReader(message: SetResourcePermissionsRsp, reader: jspb.BinaryReader): SetResourcePermissionsRsp;
}

export namespace SetResourcePermissionsRsp {
  export type AsObject = {
  }
}

export class GetResourcePermissionRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): GetResourcePermissionRqst;

  getName(): string;
  setName(value: string): GetResourcePermissionRqst;

  getType(): PermissionType;
  setType(value: PermissionType): GetResourcePermissionRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionRqst): GetResourcePermissionRqst.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionRqst;
  static deserializeBinaryFromReader(message: GetResourcePermissionRqst, reader: jspb.BinaryReader): GetResourcePermissionRqst;
}

export namespace GetResourcePermissionRqst {
  export type AsObject = {
    path: string,
    name: string,
    type: PermissionType,
  }
}

export class GetResourcePermissionRsp extends jspb.Message {
  getPermission(): Permission | undefined;
  setPermission(value?: Permission): GetResourcePermissionRsp;
  hasPermission(): boolean;
  clearPermission(): GetResourcePermissionRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetResourcePermissionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetResourcePermissionRsp): GetResourcePermissionRsp.AsObject;
  static serializeBinaryToWriter(message: GetResourcePermissionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetResourcePermissionRsp;
  static deserializeBinaryFromReader(message: GetResourcePermissionRsp, reader: jspb.BinaryReader): GetResourcePermissionRsp;
}

export namespace GetResourcePermissionRsp {
  export type AsObject = {
    permission?: Permission.AsObject,
  }
}

export class SetResourcePermissionRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): SetResourcePermissionRqst;

  getResourcetype(): string;
  setResourcetype(value: string): SetResourcePermissionRqst;

  getPermission(): Permission | undefined;
  setPermission(value?: Permission): SetResourcePermissionRqst;
  hasPermission(): boolean;
  clearPermission(): SetResourcePermissionRqst;

  getType(): PermissionType;
  setType(value: PermissionType): SetResourcePermissionRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetResourcePermissionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: SetResourcePermissionRqst): SetResourcePermissionRqst.AsObject;
  static serializeBinaryToWriter(message: SetResourcePermissionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetResourcePermissionRqst;
  static deserializeBinaryFromReader(message: SetResourcePermissionRqst, reader: jspb.BinaryReader): SetResourcePermissionRqst;
}

export namespace SetResourcePermissionRqst {
  export type AsObject = {
    path: string,
    resourcetype: string,
    permission?: Permission.AsObject,
    type: PermissionType,
  }
}

export class SetResourcePermissionRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetResourcePermissionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: SetResourcePermissionRsp): SetResourcePermissionRsp.AsObject;
  static serializeBinaryToWriter(message: SetResourcePermissionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetResourcePermissionRsp;
  static deserializeBinaryFromReader(message: SetResourcePermissionRsp, reader: jspb.BinaryReader): SetResourcePermissionRsp;
}

export namespace SetResourcePermissionRsp {
  export type AsObject = {
  }
}

export class AddResourceOwnerRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): AddResourceOwnerRqst;

  getResourcetype(): string;
  setResourcetype(value: string): AddResourceOwnerRqst;

  getSubject(): string;
  setSubject(value: string): AddResourceOwnerRqst;

  getType(): SubjectType;
  setType(value: SubjectType): AddResourceOwnerRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AddResourceOwnerRqst.AsObject;
  static toObject(includeInstance: boolean, msg: AddResourceOwnerRqst): AddResourceOwnerRqst.AsObject;
  static serializeBinaryToWriter(message: AddResourceOwnerRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AddResourceOwnerRqst;
  static deserializeBinaryFromReader(message: AddResourceOwnerRqst, reader: jspb.BinaryReader): AddResourceOwnerRqst;
}

export namespace AddResourceOwnerRqst {
  export type AsObject = {
    path: string,
    resourcetype: string,
    subject: string,
    type: SubjectType,
  }
}

export class AddResourceOwnerRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AddResourceOwnerRsp.AsObject;
  static toObject(includeInstance: boolean, msg: AddResourceOwnerRsp): AddResourceOwnerRsp.AsObject;
  static serializeBinaryToWriter(message: AddResourceOwnerRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AddResourceOwnerRsp;
  static deserializeBinaryFromReader(message: AddResourceOwnerRsp, reader: jspb.BinaryReader): AddResourceOwnerRsp;
}

export namespace AddResourceOwnerRsp {
  export type AsObject = {
  }
}

export class RemoveResourceOwnerRqst extends jspb.Message {
  getPath(): string;
  setPath(value: string): RemoveResourceOwnerRqst;

  getSubject(): string;
  setSubject(value: string): RemoveResourceOwnerRqst;

  getType(): SubjectType;
  setType(value: SubjectType): RemoveResourceOwnerRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RemoveResourceOwnerRqst.AsObject;
  static toObject(includeInstance: boolean, msg: RemoveResourceOwnerRqst): RemoveResourceOwnerRqst.AsObject;
  static serializeBinaryToWriter(message: RemoveResourceOwnerRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RemoveResourceOwnerRqst;
  static deserializeBinaryFromReader(message: RemoveResourceOwnerRqst, reader: jspb.BinaryReader): RemoveResourceOwnerRqst;
}

export namespace RemoveResourceOwnerRqst {
  export type AsObject = {
    path: string,
    subject: string,
    type: SubjectType,
  }
}

export class RemoveResourceOwnerRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RemoveResourceOwnerRsp.AsObject;
  static toObject(includeInstance: boolean, msg: RemoveResourceOwnerRsp): RemoveResourceOwnerRsp.AsObject;
  static serializeBinaryToWriter(message: RemoveResourceOwnerRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RemoveResourceOwnerRsp;
  static deserializeBinaryFromReader(message: RemoveResourceOwnerRsp, reader: jspb.BinaryReader): RemoveResourceOwnerRsp;
}

export namespace RemoveResourceOwnerRsp {
  export type AsObject = {
  }
}

export class DeleteAllAccessRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): DeleteAllAccessRqst;

  getType(): SubjectType;
  setType(value: SubjectType): DeleteAllAccessRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteAllAccessRqst.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteAllAccessRqst): DeleteAllAccessRqst.AsObject;
  static serializeBinaryToWriter(message: DeleteAllAccessRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteAllAccessRqst;
  static deserializeBinaryFromReader(message: DeleteAllAccessRqst, reader: jspb.BinaryReader): DeleteAllAccessRqst;
}

export namespace DeleteAllAccessRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
  }
}

export class DeleteAllAccessRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteAllAccessRsp.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteAllAccessRsp): DeleteAllAccessRsp.AsObject;
  static serializeBinaryToWriter(message: DeleteAllAccessRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteAllAccessRsp;
  static deserializeBinaryFromReader(message: DeleteAllAccessRsp, reader: jspb.BinaryReader): DeleteAllAccessRsp;
}

export namespace DeleteAllAccessRsp {
  export type AsObject = {
  }
}

export class ValidateAccessRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): ValidateAccessRqst;

  getType(): SubjectType;
  setType(value: SubjectType): ValidateAccessRqst;

  getPath(): string;
  setPath(value: string): ValidateAccessRqst;

  getPermission(): string;
  setPermission(value: string): ValidateAccessRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateAccessRqst.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateAccessRqst): ValidateAccessRqst.AsObject;
  static serializeBinaryToWriter(message: ValidateAccessRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateAccessRqst;
  static deserializeBinaryFromReader(message: ValidateAccessRqst, reader: jspb.BinaryReader): ValidateAccessRqst;
}

export namespace ValidateAccessRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    path: string,
    permission: string,
  }
}

export class ValidateAccessRsp extends jspb.Message {
  getHasaccess(): boolean;
  setHasaccess(value: boolean): ValidateAccessRsp;

  getAccessdenied(): boolean;
  setAccessdenied(value: boolean): ValidateAccessRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateAccessRsp.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateAccessRsp): ValidateAccessRsp.AsObject;
  static serializeBinaryToWriter(message: ValidateAccessRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateAccessRsp;
  static deserializeBinaryFromReader(message: ValidateAccessRsp, reader: jspb.BinaryReader): ValidateAccessRsp;
}

export namespace ValidateAccessRsp {
  export type AsObject = {
    hasaccess: boolean,
    accessdenied: boolean,
  }
}

export class GetActionResourceInfosRqst extends jspb.Message {
  getAction(): string;
  setAction(value: string): GetActionResourceInfosRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetActionResourceInfosRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetActionResourceInfosRqst): GetActionResourceInfosRqst.AsObject;
  static serializeBinaryToWriter(message: GetActionResourceInfosRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetActionResourceInfosRqst;
  static deserializeBinaryFromReader(message: GetActionResourceInfosRqst, reader: jspb.BinaryReader): GetActionResourceInfosRqst;
}

export namespace GetActionResourceInfosRqst {
  export type AsObject = {
    action: string,
  }
}

export class ResourceInfos extends jspb.Message {
  getIndex(): number;
  setIndex(value: number): ResourceInfos;

  getPermission(): string;
  setPermission(value: string): ResourceInfos;

  getPath(): string;
  setPath(value: string): ResourceInfos;

  getField(): string;
  setField(value: string): ResourceInfos;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ResourceInfos.AsObject;
  static toObject(includeInstance: boolean, msg: ResourceInfos): ResourceInfos.AsObject;
  static serializeBinaryToWriter(message: ResourceInfos, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ResourceInfos;
  static deserializeBinaryFromReader(message: ResourceInfos, reader: jspb.BinaryReader): ResourceInfos;
}

export namespace ResourceInfos {
  export type AsObject = {
    index: number,
    permission: string,
    path: string,
    field: string,
  }
}

export class GetActionResourceInfosRsp extends jspb.Message {
  getInfosList(): Array<ResourceInfos>;
  setInfosList(value: Array<ResourceInfos>): GetActionResourceInfosRsp;
  clearInfosList(): GetActionResourceInfosRsp;
  addInfos(value?: ResourceInfos, index?: number): ResourceInfos;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetActionResourceInfosRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetActionResourceInfosRsp): GetActionResourceInfosRsp.AsObject;
  static serializeBinaryToWriter(message: GetActionResourceInfosRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetActionResourceInfosRsp;
  static deserializeBinaryFromReader(message: GetActionResourceInfosRsp, reader: jspb.BinaryReader): GetActionResourceInfosRsp;
}

export namespace GetActionResourceInfosRsp {
  export type AsObject = {
    infosList: Array<ResourceInfos.AsObject>,
  }
}

export class ValidateActionRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): ValidateActionRqst;

  getType(): SubjectType;
  setType(value: SubjectType): ValidateActionRqst;

  getAction(): string;
  setAction(value: string): ValidateActionRqst;

  getInfosList(): Array<ResourceInfos>;
  setInfosList(value: Array<ResourceInfos>): ValidateActionRqst;
  clearInfosList(): ValidateActionRqst;
  addInfos(value?: ResourceInfos, index?: number): ResourceInfos;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateActionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateActionRqst): ValidateActionRqst.AsObject;
  static serializeBinaryToWriter(message: ValidateActionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateActionRqst;
  static deserializeBinaryFromReader(message: ValidateActionRqst, reader: jspb.BinaryReader): ValidateActionRqst;
}

export namespace ValidateActionRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    action: string,
    infosList: Array<ResourceInfos.AsObject>,
  }
}

export class ValidateActionRsp extends jspb.Message {
  getHasaccess(): boolean;
  setHasaccess(value: boolean): ValidateActionRsp;

  getAccessdenied(): boolean;
  setAccessdenied(value: boolean): ValidateActionRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateActionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateActionRsp): ValidateActionRsp.AsObject;
  static serializeBinaryToWriter(message: ValidateActionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateActionRsp;
  static deserializeBinaryFromReader(message: ValidateActionRsp, reader: jspb.BinaryReader): ValidateActionRsp;
}

export namespace ValidateActionRsp {
  export type AsObject = {
    hasaccess: boolean,
    accessdenied: boolean,
  }
}

export class SetActionResourcesPermissionsRqst extends jspb.Message {
  getPermissions(): google_protobuf_struct_pb.Struct | undefined;
  setPermissions(value?: google_protobuf_struct_pb.Struct): SetActionResourcesPermissionsRqst;
  hasPermissions(): boolean;
  clearPermissions(): SetActionResourcesPermissionsRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetActionResourcesPermissionsRqst.AsObject;
  static toObject(includeInstance: boolean, msg: SetActionResourcesPermissionsRqst): SetActionResourcesPermissionsRqst.AsObject;
  static serializeBinaryToWriter(message: SetActionResourcesPermissionsRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetActionResourcesPermissionsRqst;
  static deserializeBinaryFromReader(message: SetActionResourcesPermissionsRqst, reader: jspb.BinaryReader): SetActionResourcesPermissionsRqst;
}

export namespace SetActionResourcesPermissionsRqst {
  export type AsObject = {
    permissions?: google_protobuf_struct_pb.Struct.AsObject,
  }
}

export class SetActionResourcesPermissionsRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetActionResourcesPermissionsRsp.AsObject;
  static toObject(includeInstance: boolean, msg: SetActionResourcesPermissionsRsp): SetActionResourcesPermissionsRsp.AsObject;
  static serializeBinaryToWriter(message: SetActionResourcesPermissionsRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetActionResourcesPermissionsRsp;
  static deserializeBinaryFromReader(message: SetActionResourcesPermissionsRsp, reader: jspb.BinaryReader): SetActionResourcesPermissionsRsp;
}

export namespace SetActionResourcesPermissionsRsp {
  export type AsObject = {
  }
}

export class Share extends jspb.Message {
  getPath(): string;
  setPath(value: string): Share;

  getDomain(): string;
  setDomain(value: string): Share;

  getApplicationsList(): Array<string>;
  setApplicationsList(value: Array<string>): Share;
  clearApplicationsList(): Share;
  addApplications(value: string, index?: number): Share;

  getNodeIdentitiesList(): Array<string>;
  setNodeIdentitiesList(value: Array<string>): Share;
  clearNodeIdentitiesList(): Share;
  addNodeIdentities(value: string, index?: number): Share;

  getAccountsList(): Array<string>;
  setAccountsList(value: Array<string>): Share;
  clearAccountsList(): Share;
  addAccounts(value: string, index?: number): Share;

  getGroupsList(): Array<string>;
  setGroupsList(value: Array<string>): Share;
  clearGroupsList(): Share;
  addGroups(value: string, index?: number): Share;

  getOrganizationsList(): Array<string>;
  setOrganizationsList(value: Array<string>): Share;
  clearOrganizationsList(): Share;
  addOrganizations(value: string, index?: number): Share;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Share.AsObject;
  static toObject(includeInstance: boolean, msg: Share): Share.AsObject;
  static serializeBinaryToWriter(message: Share, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Share;
  static deserializeBinaryFromReader(message: Share, reader: jspb.BinaryReader): Share;
}

export namespace Share {
  export type AsObject = {
    path: string,
    domain: string,
    applicationsList: Array<string>,
    nodeIdentitiesList: Array<string>,
    accountsList: Array<string>,
    groupsList: Array<string>,
    organizationsList: Array<string>,
  }
}

export class GetSharedResourceRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): GetSharedResourceRqst;

  getType(): SubjectType;
  setType(value: SubjectType): GetSharedResourceRqst;

  getOwner(): string;
  setOwner(value: string): GetSharedResourceRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSharedResourceRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetSharedResourceRqst): GetSharedResourceRqst.AsObject;
  static serializeBinaryToWriter(message: GetSharedResourceRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSharedResourceRqst;
  static deserializeBinaryFromReader(message: GetSharedResourceRqst, reader: jspb.BinaryReader): GetSharedResourceRqst;
}

export namespace GetSharedResourceRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    owner: string,
  }
}

export class GetSharedResourceRsp extends jspb.Message {
  getSharedresourceList(): Array<Share>;
  setSharedresourceList(value: Array<Share>): GetSharedResourceRsp;
  clearSharedresourceList(): GetSharedResourceRsp;
  addSharedresource(value?: Share, index?: number): Share;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSharedResourceRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetSharedResourceRsp): GetSharedResourceRsp.AsObject;
  static serializeBinaryToWriter(message: GetSharedResourceRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSharedResourceRsp;
  static deserializeBinaryFromReader(message: GetSharedResourceRsp, reader: jspb.BinaryReader): GetSharedResourceRsp;
}

export namespace GetSharedResourceRsp {
  export type AsObject = {
    sharedresourceList: Array<Share.AsObject>,
  }
}

export class RemoveSubjectFromShareRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): RemoveSubjectFromShareRqst;

  getType(): SubjectType;
  setType(value: SubjectType): RemoveSubjectFromShareRqst;

  getDomain(): string;
  setDomain(value: string): RemoveSubjectFromShareRqst;

  getPath(): string;
  setPath(value: string): RemoveSubjectFromShareRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RemoveSubjectFromShareRqst.AsObject;
  static toObject(includeInstance: boolean, msg: RemoveSubjectFromShareRqst): RemoveSubjectFromShareRqst.AsObject;
  static serializeBinaryToWriter(message: RemoveSubjectFromShareRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RemoveSubjectFromShareRqst;
  static deserializeBinaryFromReader(message: RemoveSubjectFromShareRqst, reader: jspb.BinaryReader): RemoveSubjectFromShareRqst;
}

export namespace RemoveSubjectFromShareRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    domain: string,
    path: string,
  }
}

export class RemoveSubjectFromShareRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RemoveSubjectFromShareRsp.AsObject;
  static toObject(includeInstance: boolean, msg: RemoveSubjectFromShareRsp): RemoveSubjectFromShareRsp.AsObject;
  static serializeBinaryToWriter(message: RemoveSubjectFromShareRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RemoveSubjectFromShareRsp;
  static deserializeBinaryFromReader(message: RemoveSubjectFromShareRsp, reader: jspb.BinaryReader): RemoveSubjectFromShareRsp;
}

export namespace RemoveSubjectFromShareRsp {
  export type AsObject = {
  }
}

export class DeleteSubjectShareRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): DeleteSubjectShareRqst;

  getType(): SubjectType;
  setType(value: SubjectType): DeleteSubjectShareRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteSubjectShareRqst.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteSubjectShareRqst): DeleteSubjectShareRqst.AsObject;
  static serializeBinaryToWriter(message: DeleteSubjectShareRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteSubjectShareRqst;
  static deserializeBinaryFromReader(message: DeleteSubjectShareRqst, reader: jspb.BinaryReader): DeleteSubjectShareRqst;
}

export namespace DeleteSubjectShareRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
  }
}

export class DeleteSubjectShareRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteSubjectShareRsp.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteSubjectShareRsp): DeleteSubjectShareRsp.AsObject;
  static serializeBinaryToWriter(message: DeleteSubjectShareRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteSubjectShareRsp;
  static deserializeBinaryFromReader(message: DeleteSubjectShareRsp, reader: jspb.BinaryReader): DeleteSubjectShareRsp;
}

export namespace DeleteSubjectShareRsp {
  export type AsObject = {
  }
}

export class SetSubjectAllocatedSpaceRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): SetSubjectAllocatedSpaceRqst;

  getType(): SubjectType;
  setType(value: SubjectType): SetSubjectAllocatedSpaceRqst;

  getAllocatedSpace(): number;
  setAllocatedSpace(value: number): SetSubjectAllocatedSpaceRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetSubjectAllocatedSpaceRqst.AsObject;
  static toObject(includeInstance: boolean, msg: SetSubjectAllocatedSpaceRqst): SetSubjectAllocatedSpaceRqst.AsObject;
  static serializeBinaryToWriter(message: SetSubjectAllocatedSpaceRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetSubjectAllocatedSpaceRqst;
  static deserializeBinaryFromReader(message: SetSubjectAllocatedSpaceRqst, reader: jspb.BinaryReader): SetSubjectAllocatedSpaceRqst;
}

export namespace SetSubjectAllocatedSpaceRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    allocatedSpace: number,
  }
}

export class SetSubjectAllocatedSpaceRsp extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SetSubjectAllocatedSpaceRsp.AsObject;
  static toObject(includeInstance: boolean, msg: SetSubjectAllocatedSpaceRsp): SetSubjectAllocatedSpaceRsp.AsObject;
  static serializeBinaryToWriter(message: SetSubjectAllocatedSpaceRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SetSubjectAllocatedSpaceRsp;
  static deserializeBinaryFromReader(message: SetSubjectAllocatedSpaceRsp, reader: jspb.BinaryReader): SetSubjectAllocatedSpaceRsp;
}

export namespace SetSubjectAllocatedSpaceRsp {
  export type AsObject = {
  }
}

export class GetSubjectAllocatedSpaceRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): GetSubjectAllocatedSpaceRqst;

  getType(): SubjectType;
  setType(value: SubjectType): GetSubjectAllocatedSpaceRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSubjectAllocatedSpaceRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetSubjectAllocatedSpaceRqst): GetSubjectAllocatedSpaceRqst.AsObject;
  static serializeBinaryToWriter(message: GetSubjectAllocatedSpaceRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSubjectAllocatedSpaceRqst;
  static deserializeBinaryFromReader(message: GetSubjectAllocatedSpaceRqst, reader: jspb.BinaryReader): GetSubjectAllocatedSpaceRqst;
}

export namespace GetSubjectAllocatedSpaceRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
  }
}

export class GetSubjectAllocatedSpaceRsp extends jspb.Message {
  getAllocatedSpace(): number;
  setAllocatedSpace(value: number): GetSubjectAllocatedSpaceRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSubjectAllocatedSpaceRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetSubjectAllocatedSpaceRsp): GetSubjectAllocatedSpaceRsp.AsObject;
  static serializeBinaryToWriter(message: GetSubjectAllocatedSpaceRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSubjectAllocatedSpaceRsp;
  static deserializeBinaryFromReader(message: GetSubjectAllocatedSpaceRsp, reader: jspb.BinaryReader): GetSubjectAllocatedSpaceRsp;
}

export namespace GetSubjectAllocatedSpaceRsp {
  export type AsObject = {
    allocatedSpace: number,
  }
}

export class GetSubjectAvailableSpaceRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): GetSubjectAvailableSpaceRqst;

  getType(): SubjectType;
  setType(value: SubjectType): GetSubjectAvailableSpaceRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSubjectAvailableSpaceRqst.AsObject;
  static toObject(includeInstance: boolean, msg: GetSubjectAvailableSpaceRqst): GetSubjectAvailableSpaceRqst.AsObject;
  static serializeBinaryToWriter(message: GetSubjectAvailableSpaceRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSubjectAvailableSpaceRqst;
  static deserializeBinaryFromReader(message: GetSubjectAvailableSpaceRqst, reader: jspb.BinaryReader): GetSubjectAvailableSpaceRqst;
}

export namespace GetSubjectAvailableSpaceRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
  }
}

export class GetSubjectAvailableSpaceRsp extends jspb.Message {
  getAvailableSpace(): number;
  setAvailableSpace(value: number): GetSubjectAvailableSpaceRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSubjectAvailableSpaceRsp.AsObject;
  static toObject(includeInstance: boolean, msg: GetSubjectAvailableSpaceRsp): GetSubjectAvailableSpaceRsp.AsObject;
  static serializeBinaryToWriter(message: GetSubjectAvailableSpaceRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSubjectAvailableSpaceRsp;
  static deserializeBinaryFromReader(message: GetSubjectAvailableSpaceRsp, reader: jspb.BinaryReader): GetSubjectAvailableSpaceRsp;
}

export namespace GetSubjectAvailableSpaceRsp {
  export type AsObject = {
    availableSpace: number,
  }
}

export class ValidateSubjectSpaceRqst extends jspb.Message {
  getSubject(): string;
  setSubject(value: string): ValidateSubjectSpaceRqst;

  getType(): SubjectType;
  setType(value: SubjectType): ValidateSubjectSpaceRqst;

  getRequiredSpace(): number;
  setRequiredSpace(value: number): ValidateSubjectSpaceRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateSubjectSpaceRqst.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateSubjectSpaceRqst): ValidateSubjectSpaceRqst.AsObject;
  static serializeBinaryToWriter(message: ValidateSubjectSpaceRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateSubjectSpaceRqst;
  static deserializeBinaryFromReader(message: ValidateSubjectSpaceRqst, reader: jspb.BinaryReader): ValidateSubjectSpaceRqst;
}

export namespace ValidateSubjectSpaceRqst {
  export type AsObject = {
    subject: string,
    type: SubjectType,
    requiredSpace: number,
  }
}

export class ValidateSubjectSpaceRsp extends jspb.Message {
  getHasspace(): boolean;
  setHasspace(value: boolean): ValidateSubjectSpaceRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidateSubjectSpaceRsp.AsObject;
  static toObject(includeInstance: boolean, msg: ValidateSubjectSpaceRsp): ValidateSubjectSpaceRsp.AsObject;
  static serializeBinaryToWriter(message: ValidateSubjectSpaceRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidateSubjectSpaceRsp;
  static deserializeBinaryFromReader(message: ValidateSubjectSpaceRsp, reader: jspb.BinaryReader): ValidateSubjectSpaceRsp;
}

export namespace ValidateSubjectSpaceRsp {
  export type AsObject = {
    hasspace: boolean,
  }
}

export enum PermissionType { 
  DENIED = 0,
  ALLOWED = 1,
}
export enum SubjectType { 
  ACCOUNT = 0,
  NODE_IDENTITY = 1,
  GROUP = 2,
  ORGANIZATION = 3,
  APPLICATION = 4,
  ROLE = 5,
}