@blueid/access-proto 0.23.0 → 0.24.0

package/BlueCore.proto

@@ -231,6 +231,17 @@ message BlueCredentialId {
   required string id = 1 [ (nanopb).max_length = 10 ];
 }
 
+enum BlueCredentialType {
+  /* Regular credential can only open / enter */
+  Regular = 1;
+  /* Maintenance can open and update all locks within the site */
+  Maintenance = 2;
+  /* Master can open all locks within the given site and requires no refresh */
+  Master = 3;
+  /* Nfc writer allows to write any credential within this site on cards & fobs */
+  NfcWriter = 4;
+}
+
 message BlueBlacklistEntry {
   required BlueCredentialId credentialId = 1;
   required BlueLocalTimestamp expiresAt = 2;

package/BlueSDK.proto

@@ -53,4 +53,25 @@ message BlueDeviceInfo {
     BlueDeviceDetailsBluetooth bluetooth = 5;
     BlueDeviceDetailsUWB uwb = 6;
   }
+}
+
+///////////////////////////////////////////////////////////////////////
+// Credential
+///////////////////////////////////////////////////////////////////////
+
+message BlueAccessCredential {
+  required BlueCredentialId credentialId = 1;
+  required BlueCredentialType credentialType = 2;
+  optional BlueLocalTimestamp validFrom = 3;
+  optional BlueLocalTimestamp validTo = 4;
+  required bytes privateKey = 5;
+}
+
+message BlueAccessDevice {
+  required string deviceId = 1;
+  optional string name = 2;
+}
+
+message BlueAccessDeviceList {
+  repeated BlueAccessDevice devices = 1;
 }

package/cjs/BlueCore_pb.d.ts

@@ -479,6 +479,39 @@ export declare enum BlueWeekday {
   Sunday = 6,
 }
 
+/**
+ * @generated from enum BlueCredentialType
+ */
+export declare enum BlueCredentialType {
+  /**
+   * Regular credential can only open / enter 
+   *
+   * @generated from enum value: Regular = 1;
+   */
+  Regular = 1,
+
+  /**
+   * Maintenance can open and update all locks within the site 
+   *
+   * @generated from enum value: Maintenance = 2;
+   */
+  Maintenance = 2,
+
+  /**
+   * Master can open all locks within the given site and requires no refresh 
+   *
+   * @generated from enum value: Master = 3;
+   */
+  Master = 3,
+
+  /**
+   * Nfc writer allows to write any credential within this site on cards & fobs 
+   *
+   * @generated from enum value: NfcWriter = 4;
+   */
+  NfcWriter = 4,
+}
+
 /**
  * @generated from enum BlueAccessType
  */

package/cjs/BlueCore_pb.js

@@ -23,6 +23,7 @@ __export(BlueCore_pb_exports, {
   BlueBleAdvertisementInfo: () => BlueBleAdvertisementInfo,
   BlueBleManufacturerInfo: () => BlueBleManufacturerInfo,
   BlueCredentialId: () => BlueCredentialId,
+  BlueCredentialType: () => BlueCredentialType,
   BlueEvent: () => BlueEvent,
   BlueEventId: () => BlueEventId,
   BlueEventInfoAccess: () => BlueEventInfoAccess,
@@ -192,6 +193,15 @@ const BlueWeekday = import_protobuf.proto2.makeEnum(
     { no: 6, name: "Sunday" }
   ]
 );
+const BlueCredentialType = import_protobuf.proto2.makeEnum(
+  "BlueCredentialType",
+  [
+    { no: 1, name: "Regular" },
+    { no: 2, name: "Maintenance" },
+    { no: 3, name: "Master" },
+    { no: 4, name: "NfcWriter" }
+  ]
+);
 const BlueAccessType = import_protobuf.proto2.makeEnum(
   "BlueAccessType",
   [

package/cjs/BlueSDK_pb.d.ts

@@ -5,7 +5,7 @@
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto2 } from "@bufbuild/protobuf";
-import type { BlueBleManufacturerInfo } from "./BlueCore_pb.js";
+import type { BlueBleManufacturerInfo, BlueCredentialId, BlueCredentialType, BlueLocalTimestamp } from "./BlueCore_pb.js";
 
 /**
  * @generated from enum BlueDeviceType
@@ -195,3 +195,100 @@ export declare class BlueDeviceInfo extends Message<BlueDeviceInfo> {
   static equals(a: BlueDeviceInfo | PlainMessage<BlueDeviceInfo> | undefined, b: BlueDeviceInfo | PlainMessage<BlueDeviceInfo> | undefined): boolean;
 }
 
+/**
+ * @generated from message BlueAccessCredential
+ */
+export declare class BlueAccessCredential extends Message<BlueAccessCredential> {
+  /**
+   * @generated from field: required BlueCredentialId credentialId = 1;
+   */
+  credentialId?: BlueCredentialId;
+
+  /**
+   * @generated from field: required BlueCredentialType credentialType = 2;
+   */
+  credentialType: BlueCredentialType;
+
+  /**
+   * @generated from field: optional BlueLocalTimestamp validFrom = 3;
+   */
+  validFrom?: BlueLocalTimestamp;
+
+  /**
+   * @generated from field: optional BlueLocalTimestamp validTo = 4;
+   */
+  validTo?: BlueLocalTimestamp;
+
+  /**
+   * @generated from field: required bytes privateKey = 5;
+   */
+  privateKey: Uint8Array;
+
+  constructor(data?: PartialMessage<BlueAccessCredential>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessCredential";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessCredential;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessCredential;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessCredential;
+
+  static equals(a: BlueAccessCredential | PlainMessage<BlueAccessCredential> | undefined, b: BlueAccessCredential | PlainMessage<BlueAccessCredential> | undefined): boolean;
+}
+
+/**
+ * @generated from message BlueAccessDevice
+ */
+export declare class BlueAccessDevice extends Message<BlueAccessDevice> {
+  /**
+   * @generated from field: required string deviceId = 1;
+   */
+  deviceId: string;
+
+  /**
+   * @generated from field: optional string name = 2;
+   */
+  name?: string;
+
+  constructor(data?: PartialMessage<BlueAccessDevice>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessDevice";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessDevice;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessDevice;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessDevice;
+
+  static equals(a: BlueAccessDevice | PlainMessage<BlueAccessDevice> | undefined, b: BlueAccessDevice | PlainMessage<BlueAccessDevice> | undefined): boolean;
+}
+
+/**
+ * @generated from message BlueAccessDeviceList
+ */
+export declare class BlueAccessDeviceList extends Message<BlueAccessDeviceList> {
+  /**
+   * @generated from field: repeated BlueAccessDevice devices = 1;
+   */
+  devices: BlueAccessDevice[];
+
+  constructor(data?: PartialMessage<BlueAccessDeviceList>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessDeviceList";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessDeviceList;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessDeviceList;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessDeviceList;
+
+  static equals(a: BlueAccessDeviceList | PlainMessage<BlueAccessDeviceList> | undefined, b: BlueAccessDeviceList | PlainMessage<BlueAccessDeviceList> | undefined): boolean;
+}
+

package/cjs/BlueSDK_pb.js

@@ -17,6 +17,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var BlueSDK_pb_exports = {};
 __export(BlueSDK_pb_exports, {
+  BlueAccessCredential: () => BlueAccessCredential,
+  BlueAccessDevice: () => BlueAccessDevice,
+  BlueAccessDeviceList: () => BlueAccessDeviceList,
   BlueDeviceDetailsBluetooth: () => BlueDeviceDetailsBluetooth,
   BlueDeviceDetailsUWB: () => BlueDeviceDetailsUWB,
   BlueDeviceInfo: () => BlueDeviceInfo,
@@ -107,3 +110,38 @@ const BlueDeviceInfo = import_protobuf.proto2.makeMessageType(
     { no: 6, name: "uwb", kind: "message", T: BlueDeviceDetailsUWB, oneof: "details" }
   ]
 );
+const BlueAccessCredential = import_protobuf.proto2.makeMessageType(
+  "BlueAccessCredential",
+  () => [
+    { no: 1, name: "credentialId", kind: "message", T: import_BlueCore_pb.BlueCredentialId },
+    { no: 2, name: "credentialType", kind: "enum", T: import_protobuf.proto2.getEnumType(import_BlueCore_pb.BlueCredentialType) },
+    { no: 3, name: "validFrom", kind: "message", T: import_BlueCore_pb.BlueLocalTimestamp, opt: true },
+    { no: 4, name: "validTo", kind: "message", T: import_BlueCore_pb.BlueLocalTimestamp, opt: true },
+    {
+      no: 5,
+      name: "privateKey",
+      kind: "scalar",
+      T: 12
+      /* ScalarType.BYTES */
+    }
+  ]
+);
+const BlueAccessDevice = import_protobuf.proto2.makeMessageType(
+  "BlueAccessDevice",
+  () => [
+    {
+      no: 1,
+      name: "deviceId",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
+    },
+    { no: 2, name: "name", kind: "scalar", T: 9, opt: true }
+  ]
+);
+const BlueAccessDeviceList = import_protobuf.proto2.makeMessageType(
+  "BlueAccessDeviceList",
+  () => [
+    { no: 1, name: "devices", kind: "message", T: BlueAccessDevice, repeated: true }
+  ]
+);

package/es/BlueCore_pb.d.ts

@@ -479,6 +479,39 @@ export declare enum BlueWeekday {
   Sunday = 6,
 }
 
+/**
+ * @generated from enum BlueCredentialType
+ */
+export declare enum BlueCredentialType {
+  /**
+   * Regular credential can only open / enter 
+   *
+   * @generated from enum value: Regular = 1;
+   */
+  Regular = 1,
+
+  /**
+   * Maintenance can open and update all locks within the site 
+   *
+   * @generated from enum value: Maintenance = 2;
+   */
+  Maintenance = 2,
+
+  /**
+   * Master can open all locks within the given site and requires no refresh 
+   *
+   * @generated from enum value: Master = 3;
+   */
+  Master = 3,
+
+  /**
+   * Nfc writer allows to write any credential within this site on cards & fobs 
+   *
+   * @generated from enum value: NfcWriter = 4;
+   */
+  NfcWriter = 4,
+}
+
 /**
  * @generated from enum BlueAccessType
  */

package/es/BlueCore_pb.js

@@ -122,6 +122,19 @@ export const BlueWeekday = proto2.makeEnum(
   ],
 );
 
+/**
+ * @generated from enum BlueCredentialType
+ */
+export const BlueCredentialType = proto2.makeEnum(
+  "BlueCredentialType",
+  [
+    {no: 1, name: "Regular"},
+    {no: 2, name: "Maintenance"},
+    {no: 3, name: "Master"},
+    {no: 4, name: "NfcWriter"},
+  ],
+);
+
 /**
  * @generated from enum BlueAccessType
  */

package/es/BlueSDK_pb.d.ts

@@ -5,7 +5,7 @@
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto2 } from "@bufbuild/protobuf";
-import type { BlueBleManufacturerInfo } from "./BlueCore_pb.js";
+import type { BlueBleManufacturerInfo, BlueCredentialId, BlueCredentialType, BlueLocalTimestamp } from "./BlueCore_pb.js";
 
 /**
  * @generated from enum BlueDeviceType
@@ -195,3 +195,100 @@ export declare class BlueDeviceInfo extends Message<BlueDeviceInfo> {
   static equals(a: BlueDeviceInfo | PlainMessage<BlueDeviceInfo> | undefined, b: BlueDeviceInfo | PlainMessage<BlueDeviceInfo> | undefined): boolean;
 }
 
+/**
+ * @generated from message BlueAccessCredential
+ */
+export declare class BlueAccessCredential extends Message<BlueAccessCredential> {
+  /**
+   * @generated from field: required BlueCredentialId credentialId = 1;
+   */
+  credentialId?: BlueCredentialId;
+
+  /**
+   * @generated from field: required BlueCredentialType credentialType = 2;
+   */
+  credentialType: BlueCredentialType;
+
+  /**
+   * @generated from field: optional BlueLocalTimestamp validFrom = 3;
+   */
+  validFrom?: BlueLocalTimestamp;
+
+  /**
+   * @generated from field: optional BlueLocalTimestamp validTo = 4;
+   */
+  validTo?: BlueLocalTimestamp;
+
+  /**
+   * @generated from field: required bytes privateKey = 5;
+   */
+  privateKey: Uint8Array;
+
+  constructor(data?: PartialMessage<BlueAccessCredential>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessCredential";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessCredential;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessCredential;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessCredential;
+
+  static equals(a: BlueAccessCredential | PlainMessage<BlueAccessCredential> | undefined, b: BlueAccessCredential | PlainMessage<BlueAccessCredential> | undefined): boolean;
+}
+
+/**
+ * @generated from message BlueAccessDevice
+ */
+export declare class BlueAccessDevice extends Message<BlueAccessDevice> {
+  /**
+   * @generated from field: required string deviceId = 1;
+   */
+  deviceId: string;
+
+  /**
+   * @generated from field: optional string name = 2;
+   */
+  name?: string;
+
+  constructor(data?: PartialMessage<BlueAccessDevice>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessDevice";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessDevice;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessDevice;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessDevice;
+
+  static equals(a: BlueAccessDevice | PlainMessage<BlueAccessDevice> | undefined, b: BlueAccessDevice | PlainMessage<BlueAccessDevice> | undefined): boolean;
+}
+
+/**
+ * @generated from message BlueAccessDeviceList
+ */
+export declare class BlueAccessDeviceList extends Message<BlueAccessDeviceList> {
+  /**
+   * @generated from field: repeated BlueAccessDevice devices = 1;
+   */
+  devices: BlueAccessDevice[];
+
+  constructor(data?: PartialMessage<BlueAccessDeviceList>);
+
+  static readonly runtime: typeof proto2;
+  static readonly typeName = "BlueAccessDeviceList";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlueAccessDeviceList;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlueAccessDeviceList;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlueAccessDeviceList;
+
+  static equals(a: BlueAccessDeviceList | PlainMessage<BlueAccessDeviceList> | undefined, b: BlueAccessDeviceList | PlainMessage<BlueAccessDeviceList> | undefined): boolean;
+}
+

package/es/BlueSDK_pb.js

@@ -4,7 +4,7 @@
 // @ts-nocheck
 
 import { proto2 } from "@bufbuild/protobuf";
-import { BlueBleManufacturerInfo } from "./BlueCore_pb.js";
+import { BlueBleManufacturerInfo, BlueCredentialId, BlueCredentialType, BlueLocalTimestamp } from "./BlueCore_pb.js";
 
 /**
  * @generated from enum BlueDeviceType
@@ -71,3 +71,38 @@ export const BlueDeviceInfo = proto2.makeMessageType(
   ],
 );
 
+/**
+ * @generated from message BlueAccessCredential
+ */
+export const BlueAccessCredential = proto2.makeMessageType(
+  "BlueAccessCredential",
+  () => [
+    { no: 1, name: "credentialId", kind: "message", T: BlueCredentialId },
+    { no: 2, name: "credentialType", kind: "enum", T: proto2.getEnumType(BlueCredentialType) },
+    { no: 3, name: "validFrom", kind: "message", T: BlueLocalTimestamp, opt: true },
+    { no: 4, name: "validTo", kind: "message", T: BlueLocalTimestamp, opt: true },
+    { no: 5, name: "privateKey", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+  ],
+);
+
+/**
+ * @generated from message BlueAccessDevice
+ */
+export const BlueAccessDevice = proto2.makeMessageType(
+  "BlueAccessDevice",
+  () => [
+    { no: 1, name: "deviceId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+  ],
+);
+
+/**
+ * @generated from message BlueAccessDeviceList
+ */
+export const BlueAccessDeviceList = proto2.makeMessageType(
+  "BlueAccessDeviceList",
+  () => [
+    { no: 1, name: "devices", kind: "message", T: BlueAccessDevice, repeated: true },
+  ],
+);
+

package/nanopb/BlueCore.pb.c

@@ -186,3 +186,4 @@ PB_BIND(_BLUETESTENCODEDECODE, _BlueTestEncodeDecode_t, AUTO)
 
 
 
+

package/nanopb/BlueCore.pb.h

@@ -112,6 +112,17 @@ typedef enum BlueWeekday {
     BlueWeekday_Sunday = 6
 } BlueWeekday_t;
 
+typedef enum BlueCredentialType {
+    /* Regular credential can only open / enter */
+    BlueCredentialType_Regular = 1,
+    /* Maintenance can open and update all locks within the site */
+    BlueCredentialType_Maintenance = 2,
+    /* Master can open all locks within the given site and requires no refresh */
+    BlueCredentialType_Master = 3,
+    /* Nfc writer allows to write any credential within this site on cards & fobs */
+    BlueCredentialType_NfcWriter = 4
+} BlueCredentialType_t;
+
 typedef enum BlueAccessType {
     /* Access with default unlock time */
     BlueAccessType_DefaultTime = 1,
@@ -689,6 +700,10 @@ extern "C" {
 #define _BLUEWEEKDAY_MAX BlueWeekday_Sunday
 #define _BLUEWEEKDAY_ARRAYSIZE ((BlueWeekday_t)(BlueWeekday_Sunday+1))
 
+#define _BLUECREDENTIALTYPE_MIN BlueCredentialType_Regular
+#define _BLUECREDENTIALTYPE_MAX BlueCredentialType_NfcWriter
+#define _BLUECREDENTIALTYPE_ARRAYSIZE ((BlueCredentialType_t)(BlueCredentialType_NfcWriter+1))
+
 #define _BLUEACCESSTYPE_MIN BlueAccessType_DefaultTime
 #define _BLUEACCESSTYPE_MAX BlueAccessType_NoAccessBlacklisted
 #define _BLUEACCESSTYPE_ARRAYSIZE ((BlueAccessType_t)(BlueAccessType_NoAccessBlacklisted+1))

package/nanopb/BlueSDK.pb.c

@@ -18,5 +18,14 @@ PB_BIND(BLUEDEVICEDETAILSUWB, BlueDeviceDetailsUWB_t, AUTO)
 PB_BIND(BLUEDEVICEINFO, BlueDeviceInfo_t, AUTO)
 
 
+PB_BIND(BLUEACCESSCREDENTIAL, BlueAccessCredential_t, AUTO)
+
+
+PB_BIND(BLUEACCESSDEVICE, BlueAccessDevice_t, AUTO)
+
+
+PB_BIND(BLUEACCESSDEVICELIST, BlueAccessDeviceList_t, AUTO)
+
+
 
 

package/nanopb/BlueSDK.pb.h

@@ -51,6 +51,25 @@ typedef struct BlueDeviceInfo {
     } details;
 } BlueDeviceInfo_t;
 
+typedef struct BlueAccessCredential {
+    BlueCredentialId_t credentialId;
+    BlueCredentialType_t credentialType;
+    bool has_validFrom;
+    BlueLocalTimestamp_t validFrom;
+    bool has_validTo;
+    BlueLocalTimestamp_t validTo;
+    pb_callback_t privateKey;
+} BlueAccessCredential_t;
+
+typedef struct BlueAccessDevice {
+    pb_callback_t deviceId;
+    pb_callback_t name;
+} BlueAccessDevice_t;
+
+typedef struct BlueAccessDeviceList {
+    pb_callback_t devices;
+} BlueAccessDeviceList_t;
+
 
 #ifdef __cplusplus
 extern "C" {
@@ -66,16 +85,26 @@ extern "C" {
 
 #define BlueDeviceInfo_t_deviceType_ENUMTYPE BlueDeviceType_t
 
+#define BlueAccessCredential_t_credentialType_ENUMTYPE BlueCredentialType_t
+
+
+
 
 /* Initializer values for message structs */
 #define BLUEI18N_INIT_DEFAULT                    {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
 #define BLUEDEVICEDETAILSBLUETOOTH_INIT_DEFAULT  {0, 0, 0}
 #define BLUEDEVICEDETAILSUWB_INIT_DEFAULT        {0}
 #define BLUEDEVICEINFO_INIT_DEFAULT              {_BLUEDEVICETYPE_MIN, {{NULL}, NULL}, 0, false, BLUEBLEMANUFACTURERINFO_INIT_DEFAULT, 0, {BLUEDEVICEDETAILSBLUETOOTH_INIT_DEFAULT}}
+#define BLUEACCESSCREDENTIAL_INIT_DEFAULT        {BLUECREDENTIALID_INIT_DEFAULT, _BLUECREDENTIALTYPE_MIN, false, BLUELOCALTIMESTAMP_INIT_DEFAULT, false, BLUELOCALTIMESTAMP_INIT_DEFAULT, {{NULL}, NULL}}
+#define BLUEACCESSDEVICE_INIT_DEFAULT            {{{NULL}, NULL}, {{NULL}, NULL}}
+#define BLUEACCESSDEVICELIST_INIT_DEFAULT        {{{NULL}, NULL}}
 #define BLUEI18N_INIT_ZERO                       {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
 #define BLUEDEVICEDETAILSBLUETOOTH_INIT_ZERO     {0, 0, 0}
 #define BLUEDEVICEDETAILSUWB_INIT_ZERO           {0}
 #define BLUEDEVICEINFO_INIT_ZERO                 {_BLUEDEVICETYPE_MIN, {{NULL}, NULL}, 0, false, BLUEBLEMANUFACTURERINFO_INIT_ZERO, 0, {BLUEDEVICEDETAILSBLUETOOTH_INIT_ZERO}}
+#define BLUEACCESSCREDENTIAL_INIT_ZERO           {BLUECREDENTIALID_INIT_ZERO, _BLUECREDENTIALTYPE_MIN, false, BLUELOCALTIMESTAMP_INIT_ZERO, false, BLUELOCALTIMESTAMP_INIT_ZERO, {{NULL}, NULL}}
+#define BLUEACCESSDEVICE_INIT_ZERO               {{{NULL}, NULL}, {{NULL}, NULL}}
+#define BLUEACCESSDEVICELIST_INIT_ZERO           {{{NULL}, NULL}}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define BLUEI18N_NFCWAITMESSAGE_TAG              1
@@ -96,6 +125,14 @@ extern "C" {
 #define BLUEDEVICEINFO_MANUFACTURERINFO_TAG      4
 #define BLUEDEVICEINFO_BLUETOOTH_TAG             5
 #define BLUEDEVICEINFO_UWB_TAG                   6
+#define BLUEACCESSCREDENTIAL_CREDENTIALID_TAG    1
+#define BLUEACCESSCREDENTIAL_CREDENTIALTYPE_TAG  2
+#define BLUEACCESSCREDENTIAL_VALIDFROM_TAG       3
+#define BLUEACCESSCREDENTIAL_VALIDTO_TAG         4
+#define BLUEACCESSCREDENTIAL_PRIVATEKEY_TAG      5
+#define BLUEACCESSDEVICE_DEVICEID_TAG            1
+#define BLUEACCESSDEVICE_NAME_TAG                2
+#define BLUEACCESSDEVICELIST_DEVICES_TAG         1
 
 /* Struct field encoding specification for nanopb */
 #define BLUEI18N_FIELDLIST(X, a) \
@@ -135,20 +172,53 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (details,uwb,details.uwb),   6)
 #define BlueDeviceInfo_t_details_bluetooth_MSGTYPE BlueDeviceDetailsBluetooth_t
 #define BlueDeviceInfo_t_details_uwb_MSGTYPE BlueDeviceDetailsUWB_t
 
+#define BLUEACCESSCREDENTIAL_FIELDLIST(X, a) \
+X(a, STATIC,   REQUIRED, MESSAGE,  credentialId,      1) \
+X(a, STATIC,   REQUIRED, UENUM,    credentialType,    2) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  validFrom,         3) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  validTo,           4) \
+X(a, CALLBACK, REQUIRED, BYTES,    privateKey,        5)
+#define BLUEACCESSCREDENTIAL_CALLBACK pb_default_field_callback
+#define BLUEACCESSCREDENTIAL_DEFAULT (const pb_byte_t*)"\x10\x01\x00"
+#define BlueAccessCredential_t_credentialId_MSGTYPE BlueCredentialId_t
+#define BlueAccessCredential_t_validFrom_MSGTYPE BlueLocalTimestamp_t
+#define BlueAccessCredential_t_validTo_MSGTYPE BlueLocalTimestamp_t
+
+#define BLUEACCESSDEVICE_FIELDLIST(X, a) \
+X(a, CALLBACK, REQUIRED, STRING,   deviceId,          1) \
+X(a, CALLBACK, OPTIONAL, STRING,   name,              2)
+#define BLUEACCESSDEVICE_CALLBACK pb_default_field_callback
+#define BLUEACCESSDEVICE_DEFAULT NULL
+
+#define BLUEACCESSDEVICELIST_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  devices,           1)
+#define BLUEACCESSDEVICELIST_CALLBACK pb_default_field_callback
+#define BLUEACCESSDEVICELIST_DEFAULT NULL
+#define BlueAccessDeviceList_t_devices_MSGTYPE BlueAccessDevice_t
+
 extern const pb_msgdesc_t BlueI18n_t_msg;
 extern const pb_msgdesc_t BlueDeviceDetailsBluetooth_t_msg;
 extern const pb_msgdesc_t BlueDeviceDetailsUWB_t_msg;
 extern const pb_msgdesc_t BlueDeviceInfo_t_msg;
+extern const pb_msgdesc_t BlueAccessCredential_t_msg;
+extern const pb_msgdesc_t BlueAccessDevice_t_msg;
+extern const pb_msgdesc_t BlueAccessDeviceList_t_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define BLUEI18N_FIELDS &BlueI18n_t_msg
 #define BLUEDEVICEDETAILSBLUETOOTH_FIELDS &BlueDeviceDetailsBluetooth_t_msg
 #define BLUEDEVICEDETAILSUWB_FIELDS &BlueDeviceDetailsUWB_t_msg
 #define BLUEDEVICEINFO_FIELDS &BlueDeviceInfo_t_msg
+#define BLUEACCESSCREDENTIAL_FIELDS &BlueAccessCredential_t_msg
+#define BLUEACCESSDEVICE_FIELDS &BlueAccessDevice_t_msg
+#define BLUEACCESSDEVICELIST_FIELDS &BlueAccessDeviceList_t_msg
 
 /* Maximum encoded size of messages (where known) */
 /* BlueI18n_size depends on runtime parameters */
 /* BlueDeviceInfo_size depends on runtime parameters */
+/* BlueAccessCredential_size depends on runtime parameters */
+/* BlueAccessDevice_size depends on runtime parameters */
+/* BlueAccessDeviceList_size depends on runtime parameters */
 #define BLUEDEVICEDETAILSBLUETOOTH_SIZE          24
 #define BLUEDEVICEDETAILSUWB_SIZE                2
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueid/access-proto",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "BlueID Access Proto files",
   "author": "BlueID GmbH",
   "main": "cjs/index.js",

package/swift/BlueCore.pb.swift

@@ -381,6 +381,54 @@ extension BlueWeekday: CaseIterable {
 
 #endif  // swift(>=4.2)
 
+public enum BlueCredentialType: SwiftProtobuf.Enum {
+  public typealias RawValue = Int
+
+  /// Regular credential can only open / enter 
+  case regular // = 1
+
+  /// Maintenance can open and update all locks within the site 
+  case maintenance // = 2
+
+  /// Master can open all locks within the given site and requires no refresh 
+  case master // = 3
+
+  /// Nfc writer allows to write any credential within this site on cards & fobs 
+  case nfcWriter // = 4
+
+  public init() {
+    self = .regular
+  }
+
+  public init?(rawValue: Int) {
+    switch rawValue {
+    case 1: self = .regular
+    case 2: self = .maintenance
+    case 3: self = .master
+    case 4: self = .nfcWriter
+    default: return nil
+    }
+  }
+
+  public var rawValue: Int {
+    switch self {
+    case .regular: return 1
+    case .maintenance: return 2
+    case .master: return 3
+    case .nfcWriter: return 4
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension BlueCredentialType: CaseIterable {
+  // Support synthesized by the compiler.
+}
+
+#endif  // swift(>=4.2)
+
 public enum BlueAccessType: SwiftProtobuf.Enum {
   public typealias RawValue = Int
 
@@ -3361,6 +3409,7 @@ public struct _BlueTestEncodeDecode {
 extension BlueReturnCode: @unchecked Sendable {}
 extension BlueTimeUnit: @unchecked Sendable {}
 extension BlueWeekday: @unchecked Sendable {}
+extension BlueCredentialType: @unchecked Sendable {}
 extension BlueAccessType: @unchecked Sendable {}
 extension BlueTransponderType: @unchecked Sendable {}
 extension BlueHardwareType: @unchecked Sendable {}
@@ -3535,6 +3584,15 @@ extension BlueWeekday: SwiftProtobuf._ProtoNameProviding {
   ]
 }
 
+extension BlueCredentialType: SwiftProtobuf._ProtoNameProviding {
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "Regular"),
+    2: .same(proto: "Maintenance"),
+    3: .same(proto: "Master"),
+    4: .same(proto: "NfcWriter"),
+  ]
+}
+
 extension BlueAccessType: SwiftProtobuf._ProtoNameProviding {
   public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     1: .same(proto: "DefaultTime"),

package/swift/BlueSDK.pb.swift

@@ -316,6 +316,110 @@ public struct BlueDeviceInfo {
   fileprivate var _manufacturerInfo: BlueBleManufacturerInfo? = nil
 }
 
+public struct BlueAccessCredential {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var credentialID: BlueCredentialId {
+    get {return _credentialID ?? BlueCredentialId()}
+    set {_credentialID = newValue}
+  }
+  /// Returns true if `credentialID` has been explicitly set.
+  public var hasCredentialID: Bool {return self._credentialID != nil}
+  /// Clears the value of `credentialID`. Subsequent reads from it will return its default value.
+  public mutating func clearCredentialID() {self._credentialID = nil}
+
+  public var credentialType: BlueCredentialType {
+    get {return _credentialType ?? .regular}
+    set {_credentialType = newValue}
+  }
+  /// Returns true if `credentialType` has been explicitly set.
+  public var hasCredentialType: Bool {return self._credentialType != nil}
+  /// Clears the value of `credentialType`. Subsequent reads from it will return its default value.
+  public mutating func clearCredentialType() {self._credentialType = nil}
+
+  public var validFrom: BlueLocalTimestamp {
+    get {return _validFrom ?? BlueLocalTimestamp()}
+    set {_validFrom = newValue}
+  }
+  /// Returns true if `validFrom` has been explicitly set.
+  public var hasValidFrom: Bool {return self._validFrom != nil}
+  /// Clears the value of `validFrom`. Subsequent reads from it will return its default value.
+  public mutating func clearValidFrom() {self._validFrom = nil}
+
+  public var validTo: BlueLocalTimestamp {
+    get {return _validTo ?? BlueLocalTimestamp()}
+    set {_validTo = newValue}
+  }
+  /// Returns true if `validTo` has been explicitly set.
+  public var hasValidTo: Bool {return self._validTo != nil}
+  /// Clears the value of `validTo`. Subsequent reads from it will return its default value.
+  public mutating func clearValidTo() {self._validTo = nil}
+
+  public var privateKey: Data {
+    get {return _privateKey ?? Data()}
+    set {_privateKey = newValue}
+  }
+  /// Returns true if `privateKey` has been explicitly set.
+  public var hasPrivateKey: Bool {return self._privateKey != nil}
+  /// Clears the value of `privateKey`. Subsequent reads from it will return its default value.
+  public mutating func clearPrivateKey() {self._privateKey = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _credentialID: BlueCredentialId? = nil
+  fileprivate var _credentialType: BlueCredentialType? = nil
+  fileprivate var _validFrom: BlueLocalTimestamp? = nil
+  fileprivate var _validTo: BlueLocalTimestamp? = nil
+  fileprivate var _privateKey: Data? = nil
+}
+
+public struct BlueAccessDevice {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var deviceID: String {
+    get {return _deviceID ?? String()}
+    set {_deviceID = newValue}
+  }
+  /// Returns true if `deviceID` has been explicitly set.
+  public var hasDeviceID: Bool {return self._deviceID != nil}
+  /// Clears the value of `deviceID`. Subsequent reads from it will return its default value.
+  public mutating func clearDeviceID() {self._deviceID = nil}
+
+  public var name: String {
+    get {return _name ?? String()}
+    set {_name = newValue}
+  }
+  /// Returns true if `name` has been explicitly set.
+  public var hasName: Bool {return self._name != nil}
+  /// Clears the value of `name`. Subsequent reads from it will return its default value.
+  public mutating func clearName() {self._name = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _deviceID: String? = nil
+  fileprivate var _name: String? = nil
+}
+
+public struct BlueAccessDeviceList {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var devices: [BlueAccessDevice] = []
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+}
+
 #if swift(>=5.5) && canImport(_Concurrency)
 extension BlueDeviceType: @unchecked Sendable {}
 extension BlueI18n: @unchecked Sendable {}
@@ -323,6 +427,9 @@ extension BlueDeviceDetailsBluetooth: @unchecked Sendable {}
 extension BlueDeviceDetailsUWB: @unchecked Sendable {}
 extension BlueDeviceInfo: @unchecked Sendable {}
 extension BlueDeviceInfo.OneOf_Details: @unchecked Sendable {}
+extension BlueAccessCredential: @unchecked Sendable {}
+extension BlueAccessDevice: @unchecked Sendable {}
+extension BlueAccessDeviceList: @unchecked Sendable {}
 #endif  // swift(>=5.5) && canImport(_Concurrency)
 
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
@@ -622,3 +729,157 @@ extension BlueDeviceInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement
     return true
   }
 }
+
+extension BlueAccessCredential: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessCredential"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "credentialId"),
+    2: .same(proto: "credentialType"),
+    3: .same(proto: "validFrom"),
+    4: .same(proto: "validTo"),
+    5: .same(proto: "privateKey"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._credentialID == nil {return false}
+    if self._credentialType == nil {return false}
+    if self._privateKey == nil {return false}
+    if let v = self._credentialID, !v.isInitialized {return false}
+    if let v = self._validFrom, !v.isInitialized {return false}
+    if let v = self._validTo, !v.isInitialized {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._credentialID) }()
+      case 2: try { try decoder.decodeSingularEnumField(value: &self._credentialType) }()
+      case 3: try { try decoder.decodeSingularMessageField(value: &self._validFrom) }()
+      case 4: try { try decoder.decodeSingularMessageField(value: &self._validTo) }()
+      case 5: try { try decoder.decodeSingularBytesField(value: &self._privateKey) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._credentialID {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._credentialType {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._validFrom {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
+    } }()
+    try { if let v = self._validTo {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._privateKey {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 5)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessCredential, rhs: BlueAccessCredential) -> Bool {
+    if lhs._credentialID != rhs._credentialID {return false}
+    if lhs._credentialType != rhs._credentialType {return false}
+    if lhs._validFrom != rhs._validFrom {return false}
+    if lhs._validTo != rhs._validTo {return false}
+    if lhs._privateKey != rhs._privateKey {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueAccessDevice: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessDevice"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "deviceId"),
+    2: .same(proto: "name"),
+  ]
+
+  public var isInitialized: Bool {
+    if self._deviceID == nil {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._deviceID) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._name) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._deviceID {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._name {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessDevice, rhs: BlueAccessDevice) -> Bool {
+    if lhs._deviceID != rhs._deviceID {return false}
+    if lhs._name != rhs._name {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension BlueAccessDeviceList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "BlueAccessDeviceList"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "devices"),
+  ]
+
+  public var isInitialized: Bool {
+    if !SwiftProtobuf.Internal.areAllInitialized(self.devices) {return false}
+    return true
+  }
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.devices) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.devices.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.devices, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: BlueAccessDeviceList, rhs: BlueAccessDeviceList) -> Bool {
+    if lhs.devices != rhs.devices {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}