@scalekit-sdk/node 2.1.6 → 2.1.8

package/src/permission.ts

@@ -1,9 +1,9 @@
-import { Empty, PartialMessage } from '@bufbuild/protobuf';
-import { PromiseClient } from '@connectrpc/connect';
-import GrpcConnect from './connect';
-import CoreClient from './core';
-import { RolesService } from './pkg/grpc/scalekit/v1/roles/roles_connect';
-import { 
+import { Empty, PartialMessage } from "@bufbuild/protobuf";
+import { PromiseClient } from "@connectrpc/connect";
+import GrpcConnect from "./connect";
+import CoreClient from "./core";
+import { RolesService } from "./pkg/grpc/scalekit/v1/roles/roles_connect";
+import {
   CreatePermissionRequest,
   CreatePermissionResponse,
   GetPermissionRequest,
@@ -20,9 +20,27 @@ import {
   RemovePermissionFromRoleRequest,
   ListEffectiveRolePermissionsRequest,
   ListEffectiveRolePermissionsResponse,
-  CreatePermission
-} from './pkg/grpc/scalekit/v1/roles/roles_pb';
+  CreatePermission,
+} from "./pkg/grpc/scalekit/v1/roles/roles_pb";
 
+/**
+ * Client for managing permissions and role-permission assignments.
+ *
+ * Permissions represent granular access controls defining specific actions users can perform
+ * on resources (e.g., 'read:documents', 'write:settings', 'delete:users'). This client provides
+ * comprehensive permission management including CRUD operations and role assignment.
+ *
+ * **Key Concepts:**
+ * - **Direct Permissions**: Explicitly assigned to a role
+ * - **Effective Permissions**: Direct + inherited from parent roles through hierarchy
+ * - **Permission Format**: 'action:resource' (e.g., 'read:invoices', 'admin:users')
+ *
+ * @example
+ * const scalekitClient = new ScalekitClient(envUrl, clientId, clientSecret);
+ * const permissionClient = scalekitClient.permission;
+ *
+ * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Permission API Documentation}
+ */
 export default class PermissionClient {
   private client: PromiseClient<typeof RolesService>;
 
@@ -34,36 +52,86 @@ export default class PermissionClient {
   }
 
   /**
-   * Create a new permission
-   * @param {CreatePermission} permission The permission creation object
-   * @returns {Promise<CreatePermissionResponse>} The created permission
+   * Creates a new permission defining a specific action users can perform.
+   *
+   * Permissions represent granular access controls following the 'action:resource' format.
+   * Use this to define the building blocks of your access control system.
+   *
+   * @param {CreatePermission} permission - Permission object containing:
+   *   - name: Permission identifier in 'action:resource' format (e.g., 'read:documents', 'write:settings')
+   *   - description: Optional explanation of what this permission grants
+   *
+   * @returns {Promise<CreatePermissionResponse>} Created permission with ID and timestamps
+   *
+   * @example
+   * // Create basic permissions
+   * await scalekitClient.permission.createPermission({
+   *   name: 'read:invoices',
+   *   description: 'View invoice details'
+   * });
+  
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Create Permission API}
    */
-  async createPermission(permission: CreatePermission): Promise<CreatePermissionResponse> {
-    return this.coreClient.connectExec(
-      this.client.createPermission,
-      { permission }
-    );
+  async createPermission(
+    permission: CreatePermission
+  ): Promise<CreatePermissionResponse> {
+    return this.coreClient.connectExec(this.client.createPermission, {
+      permission,
+    });
   }
 
   /**
-   * Get permission by name
-   * @param {string} permissionName The permission name
-   * @returns {Promise<GetPermissionResponse>} The permission details
+   * Retrieves complete information for a specific permission.
+   *
+   * @param {string} permissionName - Permission identifier (e.g., 'read:documents')
+   *
+   * @returns {Promise<GetPermissionResponse>} Permission details including description and timestamps
+   *
+   * @example
+   * const response = await scalekitClient.permission.getPermission('read:invoices');
+   * console.log('Description:', response.permission.description);
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Get Permission API}
    */
   async getPermission(permissionName: string): Promise<GetPermissionResponse> {
-    return this.coreClient.connectExec(
-      this.client.getPermission,
-      { permissionName }
-    );
+    return this.coreClient.connectExec(this.client.getPermission, {
+      permissionName,
+    });
   }
 
   /**
-   * List all permissions
-   * @param {string} [pageToken] Token for pagination
-   * @param {number} [pageSize] Number of permissions per page
-   * @returns {Promise<ListPermissionsResponse>} List of permissions
+   * Lists all permissions with pagination support.
+   *
+   * View all permission definitions for auditing, role management, or understanding available access controls.
+   *
+   * @param {string} [pageToken] - Token for retrieving the next page
+   * @param {number} [pageSize] - Number of permissions per page (max: 100)
+   *
+   * @returns {Promise<ListPermissionsResponse>} Paginated list of permissions
+   *
+   * @example
+   * // List all permissions
+   * const response = await scalekitClient.permission.listPermissions();
+   * response.permissions.forEach(perm => {
+   *   console.log(`${perm.name}: ${perm.description}`);
+   * });
+   *
+   * @example
+   * // Paginate through permissions
+   * let pageToken = undefined;
+   * do {
+   *   const response = await scalekitClient.permission.listPermissions(pageToken, 50);
+   *   // Process permissions
+   *   pageToken = response.nextPageToken;
+   * } while (pageToken);
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | List Permissions API}
    */
-  async listPermissions(pageToken?: string, pageSize?: number): Promise<ListPermissionsResponse> {
+  async listPermissions(
+    pageToken?: string,
+    pageSize?: number
+  ): Promise<ListPermissionsResponse> {
     const request: PartialMessage<ListPermissionsRequest> = {};
     if (pageToken) {
       request.pageToken = pageToken;
@@ -71,91 +139,169 @@ export default class PermissionClient {
     if (pageSize) {
       request.pageSize = pageSize;
     }
-    
-    return this.coreClient.connectExec(
-      this.client.listPermissions,
-      request
-    );
+
+    return this.coreClient.connectExec(this.client.listPermissions, request);
   }
 
   /**
-   * Update an existing permission by name
-   * @param {string} permissionName The permission name to update
-   * @param {CreatePermission} permission The permission update object
-   * @returns {Promise<UpdatePermissionResponse>} The updated permission
+   * Updates an existing permission's attributes.
+   *
+   * Note: The permission name itself cannot be changed as it serves as the immutable identifier.
+   *
+   * @param {string} permissionName - Permission to update
+   * @param {CreatePermission} permission - Updated permission properties
+   *
+   * @returns {Promise<UpdatePermissionResponse>} Updated permission details
+   *
+   * @example
+   * await scalekitClient.permission.updatePermission('read:invoices', {
+   *   name: 'read:invoices',
+   *   description: 'View invoice details and history (updated)'
+   * });
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Update Permission API}
    */
-  async updatePermission(permissionName: string, permission: CreatePermission): Promise<UpdatePermissionResponse> {
-    return this.coreClient.connectExec(
-      this.client.updatePermission,
-      {
-        permissionName,
-        permission
-      }
-    );
+  async updatePermission(
+    permissionName: string,
+    permission: CreatePermission
+  ): Promise<UpdatePermissionResponse> {
+    return this.coreClient.connectExec(this.client.updatePermission, {
+      permissionName,
+      permission,
+    });
   }
 
   /**
-   * Delete permission by name
-   * @param {string} permissionName The permission name to be deleted
-   * @returns {Promise<Empty>} Empty response
+   * Permanently removes a permission.
+   *
+   * Ensure no active roles depend on the permission before deletion.
+   *
+   * @param {string} permissionName - Permission identifier to delete
+   *
+   * @returns {Promise<Empty>} Empty response on success
+   *
+   * @example
+   * await scalekitClient.permission.deletePermission('deprecated:feature');
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Delete Permission API}
    */
   async deletePermission(permissionName: string): Promise<Empty> {
-    return this.coreClient.connectExec(
-      this.client.deletePermission,
-      { permissionName }
-    );
+    return this.coreClient.connectExec(this.client.deletePermission, {
+      permissionName,
+    });
   }
 
   /**
-   * List all permissions associated with a role
-   * @param {string} roleName The role name to get permissions for
-   * @returns {Promise<ListRolePermissionsResponse>} List of role permissions
+   * Lists direct permissions assigned to a role (excluding inherited permissions).
+   *
+   * Use this to view explicit permission assignments without inheritance from base roles.
+   *
+   * @param {string} roleName - Role to examine
+   *
+   * @returns {Promise<ListRolePermissionsResponse>} List of directly assigned permissions only
+   *
+   * @example
+   * const response = await scalekitClient.permission.listRolePermissions('editor');
+   * console.log('Direct permissions:', response.permissions);
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | List Role Permissions API}
+   * @see {@link listEffectiveRolePermissions} - Get all permissions including inherited
    */
-  async listRolePermissions(roleName: string): Promise<ListRolePermissionsResponse> {
-    return this.coreClient.connectExec(
-      this.client.listRolePermissions,
-      { roleName }
-    );
+  async listRolePermissions(
+    roleName: string
+  ): Promise<ListRolePermissionsResponse> {
+    return this.coreClient.connectExec(this.client.listRolePermissions, {
+      roleName,
+    });
   }
 
   /**
-   * Add permissions to a role
-   * @param {string} roleName The role name to add permissions to
-   * @param {string[]} permissionNames List of permission names to add
-   * @returns {Promise<AddPermissionsToRoleResponse>} The response after adding permissions
+   * Grants additional permissions to a role without removing existing assignments.
+   *
+   * This is an incremental operation that adds new permissions while preserving existing ones.
+   * System validates permission existence before assignment.
+   *
+   * @param {string} roleName - Target role to enhance
+   * @param {string[]} permissionNames - Array of permission identifiers to add
+   *
+   * @returns {Promise<AddPermissionsToRoleResponse>} Updated list of all role permissions
+   *
+   * @example
+   * // Add multiple permissions to a role
+   * await scalekitClient.permission.addPermissionsToRole('editor', [
+   *   'read:documents',
+   *   'write:documents',
+   *   'edit:documents'
+   * ]);
+   *
+   * @example
+   * // Incrementally add permissions
+   * await scalekitClient.permission.addPermissionsToRole('support', ['read:tickets']);
+   * await scalekitClient.permission.addPermissionsToRole('support', ['update:tickets']);
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Add Permissions to Role API}
    */
-  async addPermissionsToRole(roleName: string, permissionNames: string[]): Promise<AddPermissionsToRoleResponse> {
-    return this.coreClient.connectExec(
-      this.client.addPermissionsToRole,
-      {
-        roleName,
-        permissionNames
-      }
-    );
+  async addPermissionsToRole(
+    roleName: string,
+    permissionNames: string[]
+  ): Promise<AddPermissionsToRoleResponse> {
+    return this.coreClient.connectExec(this.client.addPermissionsToRole, {
+      roleName,
+      permissionNames,
+    });
   }
 
   /**
-   * Remove a permission from a role
-   * @param {string} roleName The role name to remove permission from
-   * @param {string} permissionName The permission name to remove
-   * @returns {Promise<Empty>} Empty response
+   * Revokes a specific permission from a role, restricting access for all assigned users.
+   *
+   * Only affects direct assignments; doesn't impact inherited permissions from base roles.
+   *
+   * @param {string} roleName - Role to modify
+   * @param {string} permissionName - Permission to remove
+   *
+   * @returns {Promise<Empty>} Empty response on success
+   *
+   * @example
+   * // Remove delete permission from editor role
+   * await scalekitClient.permission.removePermissionFromRole('editor', 'delete:documents');
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | Remove Permission from Role API}
    */
-  async removePermissionFromRole(roleName: string, permissionName: string): Promise<Empty> {
-    return this.coreClient.connectExec(
-      this.client.removePermissionFromRole,
-      {
-        roleName,
-        permissionName
-      }
-    );
+  async removePermissionFromRole(
+    roleName: string,
+    permissionName: string
+  ): Promise<Empty> {
+    return this.coreClient.connectExec(this.client.removePermissionFromRole, {
+      roleName,
+      permissionName,
+    });
   }
 
   /**
-   * List all effective permissions for a role (including inherited permissions)
-   * @param {string} roleName The role name to get effective permissions for
-   * @returns {Promise<ListEffectiveRolePermissionsResponse>} List of effective role permissions
+   * Lists all effective permissions for a role including both direct and inherited permissions.
+   *
+   * This returns the complete set of capabilities available through the role hierarchy.
+   * Essential for understanding the full scope of access granted to users assigned to this role.
+   *
+   * @param {string} roleName - Role to analyze
+   *
+   * @returns {Promise<ListEffectiveRolePermissionsResponse>} Complete list including inherited permissions
+   *
+   * @example
+   * // Compare direct vs effective permissions
+   * const direct = await scalekitClient.permission.listRolePermissions('senior_editor');
+   * const effective = await scalekitClient.permission.listEffectiveRolePermissions('senior_editor');
+   *
+   * console.log('Direct permissions:', direct.permissions.length);
+   * console.log('Total effective permissions:', effective.permissions.length);
+   * console.log('Inherited:', effective.permissions.length - direct.permissions.length);
+   *
+   * @see {@link https://docs.scalekit.com/apis/#tag/permissions | List Effective Role Permissions API}
+   * @see {@link listRolePermissions} - Get only direct permissions
    */
-  async listEffectiveRolePermissions(roleName: string): Promise<ListEffectiveRolePermissionsResponse> {
+  async listEffectiveRolePermissions(
+    roleName: string
+  ): Promise<ListEffectiveRolePermissionsResponse> {
     return this.coreClient.connectExec(
       this.client.listEffectiveRolePermissions,
       { roleName }

package/src/pkg/grpc/scalekit/v1/auth/auth_connect.ts

@@ -3,7 +3,7 @@
 /* eslint-disable */
 // @ts-nocheck
 
-import { DiscoveryAuthMethodRequest, DiscoveryAuthMethodResponse, GetAuthCustomizationsRequest, GetAuthCustomizationsResponse, GetAuthErrorRequest, GetAuthErrorResponse, GetAuthFeaturesResponse, GetAuthStateResponse, ListAuthMethodsRequest, ListAuthMethodsResponse, ListUserOrganizationsResponse, SignupOrganizationRequest, SignupOrganizationResponse, UpdateLoginUserDetailsRequest, VerifyPasswordLessRequest, VerifyPasswordLessResponse } from "./auth_pb.js";
+import { DiscoveryAuthMethodRequest, DiscoveryAuthMethodResponse, GetAuthCustomizationsRequest, GetAuthCustomizationsResponse, GetAuthErrorRequest, GetAuthErrorResponse, GetAuthFeaturesResponse, GetAuthStateResponse, ListAuthMethodsRequest, ListAuthMethodsResponse, ListUserOrganizationsResponse, SignupOrganizationRequest, SignupOrganizationResponse, UpdateLoginUserDetailsRequest, VerifyPasswordLessOtpRequest, VerifyPasswordLessOtpResponse } from "./auth_pb.js";
 import { Empty, MethodKind } from "@bufbuild/protobuf";
 
 /**
@@ -35,8 +35,8 @@ export const AuthService = {
      */
     verifyPasswordLessOtp: {
       name: "VerifyPasswordLessOtp",
-      I: VerifyPasswordLessRequest,
-      O: VerifyPasswordLessResponse,
+      I: VerifyPasswordLessOtpRequest,
+      O: VerifyPasswordLessOtpResponse,
       kind: MethodKind.Unary,
     },
     /**

package/src/pkg/grpc/scalekit/v1/auth/auth_pb.ts

@@ -519,70 +519,70 @@ export class GetAuthFeaturesResponse extends Message<GetAuthFeaturesResponse> {
 }
 
 /**
- * @generated from message scalekit.v1.auth.VerifyPasswordLessRequest
+ * @generated from message scalekit.v1.auth.VerifyPasswordLessOtpRequest
  */
-export class VerifyPasswordLessRequest extends Message<VerifyPasswordLessRequest> {
+export class VerifyPasswordLessOtpRequest extends Message<VerifyPasswordLessOtpRequest> {
   /**
    * @generated from field: scalekit.v1.auth.OTPRequest otp_req = 2;
    */
   otpReq?: OTPRequest;
 
-  constructor(data?: PartialMessage<VerifyPasswordLessRequest>) {
+  constructor(data?: PartialMessage<VerifyPasswordLessOtpRequest>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime: typeof proto3 = proto3;
-  static readonly typeName = "scalekit.v1.auth.VerifyPasswordLessRequest";
+  static readonly typeName = "scalekit.v1.auth.VerifyPasswordLessOtpRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 2, name: "otp_req", kind: "message", T: OTPRequest },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessRequest {
-    return new VerifyPasswordLessRequest().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessOtpRequest {
+    return new VerifyPasswordLessOtpRequest().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessRequest {
-    return new VerifyPasswordLessRequest().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessOtpRequest {
+    return new VerifyPasswordLessOtpRequest().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessRequest {
-    return new VerifyPasswordLessRequest().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessOtpRequest {
+    return new VerifyPasswordLessOtpRequest().fromJsonString(jsonString, options);
   }
 
-  static equals(a: VerifyPasswordLessRequest | PlainMessage<VerifyPasswordLessRequest> | undefined, b: VerifyPasswordLessRequest | PlainMessage<VerifyPasswordLessRequest> | undefined): boolean {
-    return proto3.util.equals(VerifyPasswordLessRequest, a, b);
+  static equals(a: VerifyPasswordLessOtpRequest | PlainMessage<VerifyPasswordLessOtpRequest> | undefined, b: VerifyPasswordLessOtpRequest | PlainMessage<VerifyPasswordLessOtpRequest> | undefined): boolean {
+    return proto3.util.equals(VerifyPasswordLessOtpRequest, a, b);
   }
 }
 
 /**
- * @generated from message scalekit.v1.auth.VerifyPasswordLessResponse
+ * @generated from message scalekit.v1.auth.VerifyPasswordLessOtpResponse
  */
-export class VerifyPasswordLessResponse extends Message<VerifyPasswordLessResponse> {
-  constructor(data?: PartialMessage<VerifyPasswordLessResponse>) {
+export class VerifyPasswordLessOtpResponse extends Message<VerifyPasswordLessOtpResponse> {
+  constructor(data?: PartialMessage<VerifyPasswordLessOtpResponse>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime: typeof proto3 = proto3;
-  static readonly typeName = "scalekit.v1.auth.VerifyPasswordLessResponse";
+  static readonly typeName = "scalekit.v1.auth.VerifyPasswordLessOtpResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessResponse {
-    return new VerifyPasswordLessResponse().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VerifyPasswordLessOtpResponse {
+    return new VerifyPasswordLessOtpResponse().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessResponse {
-    return new VerifyPasswordLessResponse().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VerifyPasswordLessOtpResponse {
+    return new VerifyPasswordLessOtpResponse().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessResponse {
-    return new VerifyPasswordLessResponse().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VerifyPasswordLessOtpResponse {
+    return new VerifyPasswordLessOtpResponse().fromJsonString(jsonString, options);
   }
 
-  static equals(a: VerifyPasswordLessResponse | PlainMessage<VerifyPasswordLessResponse> | undefined, b: VerifyPasswordLessResponse | PlainMessage<VerifyPasswordLessResponse> | undefined): boolean {
-    return proto3.util.equals(VerifyPasswordLessResponse, a, b);
+  static equals(a: VerifyPasswordLessOtpResponse | PlainMessage<VerifyPasswordLessOtpResponse> | undefined, b: VerifyPasswordLessOtpResponse | PlainMessage<VerifyPasswordLessOtpResponse> | undefined): boolean {
+    return proto3.util.equals(VerifyPasswordLessOtpResponse, a, b);
   }
 }
 

package/src/pkg/grpc/scalekit/v1/auth/webauthn_connect.ts

@@ -0,0 +1,89 @@
+// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts"
+// @generated from file scalekit/v1/auth/webauthn.proto (package scalekit.v1.auth.webauthn, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import { BeginAuthenticationRequest, BeginAuthenticationResponse, BeginRegistrationRequest, BeginRegistrationResponse, DeleteCredentialRequest, DeleteCredentialResponse, FinishAuthenticationRequest, FinishAuthenticationResponse, FinishRegistrationRequest, FinishRegistrationResponse, GetRelatedOriginsRequest, GetRelatedOriginsResponse, ListCredentialsRequest, ListCredentialsResponse, UpdateCredentialRequest, UpdateCredentialResponse } from "./webauthn_pb.js";
+import { MethodKind } from "@bufbuild/protobuf";
+
+/**
+ * @generated from service scalekit.v1.auth.webauthn.WebAuthnService
+ */
+export const WebAuthnService = {
+  typeName: "scalekit.v1.auth.webauthn.WebAuthnService",
+  methods: {
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.BeginRegistration
+     */
+    beginRegistration: {
+      name: "BeginRegistration",
+      I: BeginRegistrationRequest,
+      O: BeginRegistrationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.FinishRegistration
+     */
+    finishRegistration: {
+      name: "FinishRegistration",
+      I: FinishRegistrationRequest,
+      O: FinishRegistrationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.BeginAuthentication
+     */
+    beginAuthentication: {
+      name: "BeginAuthentication",
+      I: BeginAuthenticationRequest,
+      O: BeginAuthenticationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.FinishAuthentication
+     */
+    finishAuthentication: {
+      name: "FinishAuthentication",
+      I: FinishAuthenticationRequest,
+      O: FinishAuthenticationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.ListCredentials
+     */
+    listCredentials: {
+      name: "ListCredentials",
+      I: ListCredentialsRequest,
+      O: ListCredentialsResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.DeleteCredential
+     */
+    deleteCredential: {
+      name: "DeleteCredential",
+      I: DeleteCredentialRequest,
+      O: DeleteCredentialResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.UpdateCredential
+     */
+    updateCredential: {
+      name: "UpdateCredential",
+      I: UpdateCredentialRequest,
+      O: UpdateCredentialResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc scalekit.v1.auth.webauthn.WebAuthnService.GetRelatedOrigins
+     */
+    getRelatedOrigins: {
+      name: "GetRelatedOrigins",
+      I: GetRelatedOriginsRequest,
+      O: GetRelatedOriginsResponse,
+      kind: MethodKind.Unary,
+    },
+  }
+} as const;
+