@ragnaraven/zitadel-node-dual/dist/api/generated/zitadel/auth.js

Library for API access to ZITADEL with modern ES import syntax. Works everywhere - NestJS, Node.js, any TypeScript environment. No more require()!

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var auth_exports = {};
__export(auth_exports, {
  AddMyAuthFactorOTPEmailRequest: () => AddMyAuthFactorOTPEmailRequest,
  AddMyAuthFactorOTPEmailResponse: () => AddMyAuthFactorOTPEmailResponse,
  AddMyAuthFactorOTPRequest: () => AddMyAuthFactorOTPRequest,
  AddMyAuthFactorOTPResponse: () => AddMyAuthFactorOTPResponse,
  AddMyAuthFactorOTPSMSRequest: () => AddMyAuthFactorOTPSMSRequest,
  AddMyAuthFactorOTPSMSResponse: () => AddMyAuthFactorOTPSMSResponse,
  AddMyAuthFactorU2FRequest: () => AddMyAuthFactorU2FRequest,
  AddMyAuthFactorU2FResponse: () => AddMyAuthFactorU2FResponse,
  AddMyPasswordlessLinkRequest: () => AddMyPasswordlessLinkRequest,
  AddMyPasswordlessLinkResponse: () => AddMyPasswordlessLinkResponse,
  AddMyPasswordlessRequest: () => AddMyPasswordlessRequest,
  AddMyPasswordlessResponse: () => AddMyPasswordlessResponse,
  AuthServiceDefinition: () => AuthServiceDefinition,
  BulkRemoveMyMetadataRequest: () => BulkRemoveMyMetadataRequest,
  BulkRemoveMyMetadataResponse: () => BulkRemoveMyMetadataResponse,
  BulkSetMyMetadataRequest: () => BulkSetMyMetadataRequest,
  BulkSetMyMetadataRequest_Metadata: () => BulkSetMyMetadataRequest_Metadata,
  BulkSetMyMetadataResponse: () => BulkSetMyMetadataResponse,
  GetMyEmailRequest: () => GetMyEmailRequest,
  GetMyEmailResponse: () => GetMyEmailResponse,
  GetMyLabelPolicyRequest: () => GetMyLabelPolicyRequest,
  GetMyLabelPolicyResponse: () => GetMyLabelPolicyResponse,
  GetMyLoginPolicyRequest: () => GetMyLoginPolicyRequest,
  GetMyLoginPolicyResponse: () => GetMyLoginPolicyResponse,
  GetMyMetadataRequest: () => GetMyMetadataRequest,
  GetMyMetadataResponse: () => GetMyMetadataResponse,
  GetMyPasswordComplexityPolicyRequest: () => GetMyPasswordComplexityPolicyRequest,
  GetMyPasswordComplexityPolicyResponse: () => GetMyPasswordComplexityPolicyResponse,
  GetMyPhoneRequest: () => GetMyPhoneRequest,
  GetMyPhoneResponse: () => GetMyPhoneResponse,
  GetMyPrivacyPolicyRequest: () => GetMyPrivacyPolicyRequest,
  GetMyPrivacyPolicyResponse: () => GetMyPrivacyPolicyResponse,
  GetMyProfileRequest: () => GetMyProfileRequest,
  GetMyProfileResponse: () => GetMyProfileResponse,
  GetMyUserRequest: () => GetMyUserRequest,
  GetMyUserResponse: () => GetMyUserResponse,
  GetSupportedLanguagesRequest: () => GetSupportedLanguagesRequest,
  GetSupportedLanguagesResponse: () => GetSupportedLanguagesResponse,
  HealthzRequest: () => HealthzRequest,
  HealthzResponse: () => HealthzResponse,
  ListMyAuthFactorsRequest: () => ListMyAuthFactorsRequest,
  ListMyAuthFactorsResponse: () => ListMyAuthFactorsResponse,
  ListMyLinkedIDPsRequest: () => ListMyLinkedIDPsRequest,
  ListMyLinkedIDPsResponse: () => ListMyLinkedIDPsResponse,
  ListMyMembershipsRequest: () => ListMyMembershipsRequest,
  ListMyMembershipsResponse: () => ListMyMembershipsResponse,
  ListMyMetadataRequest: () => ListMyMetadataRequest,
  ListMyMetadataResponse: () => ListMyMetadataResponse,
  ListMyPasswordlessRequest: () => ListMyPasswordlessRequest,
  ListMyPasswordlessResponse: () => ListMyPasswordlessResponse,
  ListMyProjectOrgsRequest: () => ListMyProjectOrgsRequest,
  ListMyProjectOrgsResponse: () => ListMyProjectOrgsResponse,
  ListMyProjectPermissionsRequest: () => ListMyProjectPermissionsRequest,
  ListMyProjectPermissionsResponse: () => ListMyProjectPermissionsResponse,
  ListMyRefreshTokensRequest: () => ListMyRefreshTokensRequest,
  ListMyRefreshTokensResponse: () => ListMyRefreshTokensResponse,
  ListMyUserChangesRequest: () => ListMyUserChangesRequest,
  ListMyUserChangesResponse: () => ListMyUserChangesResponse,
  ListMyUserGrantsRequest: () => ListMyUserGrantsRequest,
  ListMyUserGrantsResponse: () => ListMyUserGrantsResponse,
  ListMyUserSessionsRequest: () => ListMyUserSessionsRequest,
  ListMyUserSessionsResponse: () => ListMyUserSessionsResponse,
  ListMyZitadelPermissionsRequest: () => ListMyZitadelPermissionsRequest,
  ListMyZitadelPermissionsResponse: () => ListMyZitadelPermissionsResponse,
  RemoveMyAuthFactorOTPEmailRequest: () => RemoveMyAuthFactorOTPEmailRequest,
  RemoveMyAuthFactorOTPEmailResponse: () => RemoveMyAuthFactorOTPEmailResponse,
  RemoveMyAuthFactorOTPRequest: () => RemoveMyAuthFactorOTPRequest,
  RemoveMyAuthFactorOTPResponse: () => RemoveMyAuthFactorOTPResponse,
  RemoveMyAuthFactorOTPSMSRequest: () => RemoveMyAuthFactorOTPSMSRequest,
  RemoveMyAuthFactorOTPSMSResponse: () => RemoveMyAuthFactorOTPSMSResponse,
  RemoveMyAuthFactorU2FRequest: () => RemoveMyAuthFactorU2FRequest,
  RemoveMyAuthFactorU2FResponse: () => RemoveMyAuthFactorU2FResponse,
  RemoveMyAvatarRequest: () => RemoveMyAvatarRequest,
  RemoveMyAvatarResponse: () => RemoveMyAvatarResponse,
  RemoveMyLinkedIDPRequest: () => RemoveMyLinkedIDPRequest,
  RemoveMyLinkedIDPResponse: () => RemoveMyLinkedIDPResponse,
  RemoveMyMetadataRequest: () => RemoveMyMetadataRequest,
  RemoveMyMetadataResponse: () => RemoveMyMetadataResponse,
  RemoveMyPasswordlessRequest: () => RemoveMyPasswordlessRequest,
  RemoveMyPasswordlessResponse: () => RemoveMyPasswordlessResponse,
  RemoveMyPhoneRequest: () => RemoveMyPhoneRequest,
  RemoveMyPhoneResponse: () => RemoveMyPhoneResponse,
  RemoveMyUserRequest: () => RemoveMyUserRequest,
  RemoveMyUserResponse: () => RemoveMyUserResponse,
  ResendMyEmailVerificationRequest: () => ResendMyEmailVerificationRequest,
  ResendMyEmailVerificationResponse: () => ResendMyEmailVerificationResponse,
  ResendMyPhoneVerificationRequest: () => ResendMyPhoneVerificationRequest,
  ResendMyPhoneVerificationResponse: () => ResendMyPhoneVerificationResponse,
  RevokeAllMyRefreshTokensRequest: () => RevokeAllMyRefreshTokensRequest,
  RevokeAllMyRefreshTokensResponse: () => RevokeAllMyRefreshTokensResponse,
  RevokeMyRefreshTokenRequest: () => RevokeMyRefreshTokenRequest,
  RevokeMyRefreshTokenResponse: () => RevokeMyRefreshTokenResponse,
  SendMyPasswordlessLinkRequest: () => SendMyPasswordlessLinkRequest,
  SendMyPasswordlessLinkResponse: () => SendMyPasswordlessLinkResponse,
  SetMyEmailRequest: () => SetMyEmailRequest,
  SetMyEmailResponse: () => SetMyEmailResponse,
  SetMyMetadataRequest: () => SetMyMetadataRequest,
  SetMyMetadataResponse: () => SetMyMetadataResponse,
  SetMyPhoneRequest: () => SetMyPhoneRequest,
  SetMyPhoneResponse: () => SetMyPhoneResponse,
  UpdateMyPasswordRequest: () => UpdateMyPasswordRequest,
  UpdateMyPasswordResponse: () => UpdateMyPasswordResponse,
  UpdateMyProfileRequest: () => UpdateMyProfileRequest,
  UpdateMyProfileResponse: () => UpdateMyProfileResponse,
  UpdateMyUserNameRequest: () => UpdateMyUserNameRequest,
  UpdateMyUserNameResponse: () => UpdateMyUserNameResponse,
  UserGrant: () => UserGrant,
  VerifyMyAuthFactorOTPRequest: () => VerifyMyAuthFactorOTPRequest,
  VerifyMyAuthFactorOTPResponse: () => VerifyMyAuthFactorOTPResponse,
  VerifyMyAuthFactorU2FRequest: () => VerifyMyAuthFactorU2FRequest,
  VerifyMyAuthFactorU2FResponse: () => VerifyMyAuthFactorU2FResponse,
  VerifyMyEmailRequest: () => VerifyMyEmailRequest,
  VerifyMyEmailResponse: () => VerifyMyEmailResponse,
  VerifyMyPasswordlessRequest: () => VerifyMyPasswordlessRequest,
  VerifyMyPasswordlessResponse: () => VerifyMyPasswordlessResponse,
  VerifyMyPhoneRequest: () => VerifyMyPhoneRequest,
  VerifyMyPhoneResponse: () => VerifyMyPhoneResponse,
  protobufPackage: () => protobufPackage
});
module.exports = __toCommonJS(auth_exports);
var import_wire = require("@bufbuild/protobuf/wire");
var import_long = __toESM(require("long"));
var import_duration = require("../google/protobuf/duration.js");
var import_timestamp = require("../google/protobuf/timestamp.js");
var import_change = require("./change.js");
var import_idp = require("./idp.js");
var import_metadata = require("./metadata.js");
var import_object = require("./object.js");
var import_org = require("./org.js");
var import_policy = require("./policy.js");
var import_user = require("./user.js");
const protobufPackage = "zitadel.auth.v1";
function createBaseHealthzRequest() {
  return {};
}
const HealthzRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseHealthzRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return HealthzRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseHealthzRequest();
    return message;
  }
};
function createBaseHealthzResponse() {
  return {};
}
const HealthzResponse = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseHealthzResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return HealthzResponse.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseHealthzResponse();
    return message;
  }
};
function createBaseGetSupportedLanguagesRequest() {
  return {};
}
const GetSupportedLanguagesRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetSupportedLanguagesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return GetSupportedLanguagesRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseGetSupportedLanguagesRequest();
    return message;
  }
};
function createBaseGetSupportedLanguagesResponse() {
  return { languages: [] };
}
const GetSupportedLanguagesResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.languages) {
      writer.uint32(10).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetSupportedLanguagesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.languages.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      languages: globalThis.Array.isArray(object?.languages) ? object.languages.map((e) => globalThis.String(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.languages?.length) {
      obj.languages = message.languages;
    }
    return obj;
  },
  create(base) {
    return GetSupportedLanguagesResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseGetSupportedLanguagesResponse();
    message.languages = object.languages?.map((e) => e) || [];
    return message;
  }
};
function createBaseGetMyUserRequest() {
  return {};
}
const GetMyUserRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetMyUserRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return GetMyUserRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseGetMyUserRequest();
    return message;
  }
};
function createBaseGetMyUserResponse() {
  return { user: void 0, lastLogin: void 0 };
}
const GetMyUserResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.user !== void 0) {
      import_user.User.encode(message.user, writer.uint32(10).fork()).join();
    }
    if (message.lastLogin !== void 0) {
      import_timestamp.Timestamp.encode(toTimestamp(message.lastLogin), writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetMyUserResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.user = import_user.User.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.lastLogin = fromTimestamp(import_timestamp.Timestamp.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      user: isSet(object.user) ? import_user.User.fromJSON(object.user) : void 0,
      lastLogin: isSet(object.lastLogin) ? fromJsonTimestamp(object.lastLogin) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.user !== void 0) {
      obj.user = import_user.User.toJSON(message.user);
    }
    if (message.lastLogin !== void 0) {
      obj.lastLogin = message.lastLogin.toISOString();
    }
    return obj;
  },
  create(base) {
    return GetMyUserResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseGetMyUserResponse();
    message.user = object.user !== void 0 && object.user !== null ? import_user.User.fromPartial(object.user) : void 0;
    message.lastLogin = object.lastLogin ?? void 0;
    return message;
  }
};
function createBaseRemoveMyUserRequest() {
  return {};
}
const RemoveMyUserRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRemoveMyUserRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return RemoveMyUserRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseRemoveMyUserRequest();
    return message;
  }
};
function createBaseRemoveMyUserResponse() {
  return { details: void 0 };
}
const RemoveMyUserResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRemoveMyUserResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    return obj;
  },
  create(base) {
    return RemoveMyUserResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseRemoveMyUserResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    return message;
  }
};
function createBaseListMyUserChangesRequest() {
  return { query: void 0 };
}
const ListMyUserChangesRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.query !== void 0) {
      import_change.ChangeQuery.encode(message.query, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyUserChangesRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.query = import_change.ChangeQuery.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { query: isSet(object.query) ? import_change.ChangeQuery.fromJSON(object.query) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.query !== void 0) {
      obj.query = import_change.ChangeQuery.toJSON(message.query);
    }
    return obj;
  },
  create(base) {
    return ListMyUserChangesRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListMyUserChangesRequest();
    message.query = object.query !== void 0 && object.query !== null ? import_change.ChangeQuery.fromPartial(object.query) : void 0;
    return message;
  }
};
function createBaseListMyUserChangesResponse() {
  return { result: [] };
}
const ListMyUserChangesResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.result) {
      import_change.Change.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyUserChangesResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.result.push(import_change.Change.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      result: globalThis.Array.isArray(object?.result) ? object.result.map((e) => import_change.Change.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.result?.length) {
      obj.result = message.result.map((e) => import_change.Change.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return ListMyUserChangesResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListMyUserChangesResponse();
    message.result = object.result?.map((e) => import_change.Change.fromPartial(e)) || [];
    return message;
  }
};
function createBaseListMyUserSessionsRequest() {
  return {};
}
const ListMyUserSessionsRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyUserSessionsRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return ListMyUserSessionsRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseListMyUserSessionsRequest();
    return message;
  }
};
function createBaseListMyUserSessionsResponse() {
  return { result: [] };
}
const ListMyUserSessionsResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.result) {
      import_user.Session.encode(v, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyUserSessionsResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.result.push(import_user.Session.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      result: globalThis.Array.isArray(object?.result) ? object.result.map((e) => import_user.Session.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.result?.length) {
      obj.result = message.result.map((e) => import_user.Session.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return ListMyUserSessionsResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListMyUserSessionsResponse();
    message.result = object.result?.map((e) => import_user.Session.fromPartial(e)) || [];
    return message;
  }
};
function createBaseListMyMetadataRequest() {
  return { query: void 0, queries: [] };
}
const ListMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.query !== void 0) {
      import_object.ListQuery.encode(message.query, writer.uint32(10).fork()).join();
    }
    for (const v of message.queries) {
      import_metadata.MetadataQuery.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.query = import_object.ListQuery.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.queries.push(import_metadata.MetadataQuery.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      query: isSet(object.query) ? import_object.ListQuery.fromJSON(object.query) : void 0,
      queries: globalThis.Array.isArray(object?.queries) ? object.queries.map((e) => import_metadata.MetadataQuery.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.query !== void 0) {
      obj.query = import_object.ListQuery.toJSON(message.query);
    }
    if (message.queries?.length) {
      obj.queries = message.queries.map((e) => import_metadata.MetadataQuery.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return ListMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListMyMetadataRequest();
    message.query = object.query !== void 0 && object.query !== null ? import_object.ListQuery.fromPartial(object.query) : void 0;
    message.queries = object.queries?.map((e) => import_metadata.MetadataQuery.fromPartial(e)) || [];
    return message;
  }
};
function createBaseListMyMetadataResponse() {
  return { details: void 0, result: [] };
}
const ListMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ListDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    for (const v of message.result) {
      import_metadata.Metadata.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ListDetails.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.result.push(import_metadata.Metadata.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      details: isSet(object.details) ? import_object.ListDetails.fromJSON(object.details) : void 0,
      result: globalThis.Array.isArray(object?.result) ? object.result.map((e) => import_metadata.Metadata.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ListDetails.toJSON(message.details);
    }
    if (message.result?.length) {
      obj.result = message.result.map((e) => import_metadata.Metadata.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return ListMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseListMyMetadataResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ListDetails.fromPartial(object.details) : void 0;
    message.result = object.result?.map((e) => import_metadata.Metadata.fromPartial(e)) || [];
    return message;
  }
};
function createBaseGetMyMetadataRequest() {
  return { key: "" };
}
const GetMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { key: isSet(object.key) ? globalThis.String(object.key) : "" };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    return obj;
  },
  create(base) {
    return GetMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseGetMyMetadataRequest();
    message.key = object.key ?? "";
    return message;
  }
};
function createBaseGetMyMetadataResponse() {
  return { metadata: void 0 };
}
const GetMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.metadata !== void 0) {
      import_metadata.Metadata.encode(message.metadata, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseGetMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.metadata = import_metadata.Metadata.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { metadata: isSet(object.metadata) ? import_metadata.Metadata.fromJSON(object.metadata) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.metadata !== void 0) {
      obj.metadata = import_metadata.Metadata.toJSON(message.metadata);
    }
    return obj;
  },
  create(base) {
    return GetMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseGetMyMetadataResponse();
    message.metadata = object.metadata !== void 0 && object.metadata !== null ? import_metadata.Metadata.fromPartial(object.metadata) : void 0;
    return message;
  }
};
function createBaseSetMyMetadataRequest() {
  return { key: "", value: Buffer.alloc(0) };
}
const SetMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value.length !== 0) {
      writer.uint32(18).bytes(message.value);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseSetMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.value = Buffer.from(reader.bytes());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? Buffer.from(bytesFromBase64(object.value)) : Buffer.alloc(0)
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    if (message.value.length !== 0) {
      obj.value = base64FromBytes(message.value);
    }
    return obj;
  },
  create(base) {
    return SetMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseSetMyMetadataRequest();
    message.key = object.key ?? "";
    message.value = object.value ?? Buffer.alloc(0);
    return message;
  }
};
function createBaseSetMyMetadataResponse() {
  return { details: void 0 };
}
const SetMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseSetMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    return obj;
  },
  create(base) {
    return SetMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseSetMyMetadataResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    return message;
  }
};
function createBaseBulkSetMyMetadataRequest() {
  return { metadata: [] };
}
const BulkSetMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.metadata) {
      BulkSetMyMetadataRequest_Metadata.encode(v, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBulkSetMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.metadata.push(BulkSetMyMetadataRequest_Metadata.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      metadata: globalThis.Array.isArray(object?.metadata) ? object.metadata.map((e) => BulkSetMyMetadataRequest_Metadata.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.metadata?.length) {
      obj.metadata = message.metadata.map((e) => BulkSetMyMetadataRequest_Metadata.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return BulkSetMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseBulkSetMyMetadataRequest();
    message.metadata = object.metadata?.map((e) => BulkSetMyMetadataRequest_Metadata.fromPartial(e)) || [];
    return message;
  }
};
function createBaseBulkSetMyMetadataRequest_Metadata() {
  return { key: "", value: Buffer.alloc(0) };
}
const BulkSetMyMetadataRequest_Metadata = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value.length !== 0) {
      writer.uint32(18).bytes(message.value);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBulkSetMyMetadataRequest_Metadata();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.value = Buffer.from(reader.bytes());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? Buffer.from(bytesFromBase64(object.value)) : Buffer.alloc(0)
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    if (message.value.length !== 0) {
      obj.value = base64FromBytes(message.value);
    }
    return obj;
  },
  create(base) {
    return BulkSetMyMetadataRequest_Metadata.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseBulkSetMyMetadataRequest_Metadata();
    message.key = object.key ?? "";
    message.value = object.value ?? Buffer.alloc(0);
    return message;
  }
};
function createBaseBulkSetMyMetadataResponse() {
  return { details: void 0 };
}
const BulkSetMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBulkSetMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    return obj;
  },
  create(base) {
    return BulkSetMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseBulkSetMyMetadataResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    return message;
  }
};
function createBaseRemoveMyMetadataRequest() {
  return { key: "" };
}
const RemoveMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRemoveMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { key: isSet(object.key) ? globalThis.String(object.key) : "" };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    return obj;
  },
  create(base) {
    return RemoveMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseRemoveMyMetadataRequest();
    message.key = object.key ?? "";
    return message;
  }
};
function createBaseRemoveMyMetadataResponse() {
  return { details: void 0 };
}
const RemoveMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseRemoveMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    return obj;
  },
  create(base) {
    return RemoveMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseRemoveMyMetadataResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    return message;
  }
};
function createBaseBulkRemoveMyMetadataRequest() {
  return { keys: [] };
}
const BulkRemoveMyMetadataRequest = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    for (const v of message.keys) {
      writer.uint32(10).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBulkRemoveMyMetadataRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.keys.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e) => globalThis.String(e)) : [] };
  },
  toJSON(message) {
    const obj = {};
    if (message.keys?.length) {
      obj.keys = message.keys;
    }
    return obj;
  },
  create(base) {
    return BulkRemoveMyMetadataRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseBulkRemoveMyMetadataRequest();
    message.keys = object.keys?.map((e) => e) || [];
    return message;
  }
};
function createBaseBulkRemoveMyMetadataResponse() {
  return { details: void 0 };
}
const BulkRemoveMyMetadataResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ObjectDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseBulkRemoveMyMetadataResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ObjectDetails.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? import_object.ObjectDetails.fromJSON(object.details) : void 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== void 0) {
      obj.details = import_object.ObjectDetails.toJSON(message.details);
    }
    return obj;
  },
  create(base) {
    return BulkRemoveMyMetadataResponse.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseBulkRemoveMyMetadataResponse();
    message.details = object.details !== void 0 && object.details !== null ? import_object.ObjectDetails.fromPartial(object.details) : void 0;
    return message;
  }
};
function createBaseListMyRefreshTokensRequest() {
  return {};
}
const ListMyRefreshTokensRequest = {
  encode(_, writer = new import_wire.BinaryWriter()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyRefreshTokensRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return ListMyRefreshTokensRequest.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseListMyRefreshTokensRequest();
    return message;
  }
};
function createBaseListMyRefreshTokensResponse() {
  return { details: void 0, result: [] };
}
const ListMyRefreshTokensResponse = {
  encode(message, writer = new import_wire.BinaryWriter()) {
    if (message.details !== void 0) {
      import_object.ListDetails.encode(message.details, writer.uint32(10).fork()).join();
    }
    for (const v of message.result) {
      import_user.RefreshToken.encode(v, writer.uint32(18).fork()).join();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
    const end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseListMyRefreshTokensResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.details = import_object.ListDetails.decode(reader, reader.uint32());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.result.push(import_user.RefreshToken.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);