Lock operations resource

Get single lock

Kotlin

// Returns a LockResponse
val response = sdk.lockOperations().getSingleLock(LOCK_ID)

Java

// Returns a CompletableFuture<LockResponse>
var response = sdk.lockOperations().getSingleLockAsync(LOCK_ID);

Swift

// Returns a LockResponse asynchronously
let response = await sdk.lockOperations().getSingleLock(lockId: LOCK_ID)

JavaScript

// Returns a Promise<LockResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getSingleLock("LOCK_ID");

C#

// Returns a Task<LockResponse>
var response = await sdk.GetLockOperations().GetSingleLock(LOCK_ID);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_single_lock("LOCK_ID")

Get lock audit trail

Kotlin

// Returns a List<LockAuditTrailResponse>
val response = sdk.lockOperations().getLockAuditTrail(LOCK_ID)

Java

// Returns a CompletableFuture<List<LockAuditTrailResponse>>
var response = sdk.lockOperations().getLockAuditTrailAsync(LOCK_ID);

Swift

// Returns a Array<LockAuditTrailResponse> asynchronously
let response = await sdk.lockOperations().getLockAuditTrail(
  lockId: LOCK_ID, 
  start: START, 
  end: END
)

JavaScript

// Returns a Promise<Array<LockAuditTrailResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getLockAuditTrail("LOCK_ID");

C#

// Returns a Task<List<LockAuditTrailResponse>>
var response = await sdk.GetLockOperations().GetLockAuditTrail(LOCK_ID);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_lock_audit_trail("LOCK_ID")

Get audit for user

Kotlin

// Returns a List<AuditResponse>
val response = sdk.lockOperations().getAuditForUser(USER_ID)

Java

// Returns a CompletableFuture<List<AuditResponse>>
var response = sdk.lockOperations().getAuditForUserAsync(USER_ID);

Swift

// Returns a Array<AuditResponse> asynchronously
let response = await sdk.lockOperations().getAuditForUser(
  userId: USER_ID, 
  start: START, 
  end: END
)

JavaScript

// Returns a Promise<Array<AuditResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getAuditForUser("USER_ID");

C#

// Returns a Task<List<AuditResponse>>
var response = await sdk.GetLockOperations().GetAuditForUser(USER_ID);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_audit_for_user("USER_ID")

Get users for lock

Kotlin

// Returns a List<UserLockResponse>
val response = sdk.lockOperations().getUsersForLock(LOCK_ID)

Java

// Returns a CompletableFuture<List<UserLockResponse>>
var response = sdk.lockOperations().getUsersForLockAsync(LOCK_ID);

Swift

// Returns a Array<UserLockResponse> asynchronously
let response = await sdk.lockOperations().getUsersForLock(lockId: LOCK_ID)

JavaScript

// Returns a Promise<Array<UserLockResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUsersForLock(LOCK_ID);

C#

// Returns a Task<List<UserLockResponse>>
var response = await sdk.GetLockOperations().GetUsersForLock(LOCK_ID);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_users_for_lock("LOCK_ID")

Get locks for user

Kotlin

// Returns a LockUserResponse
val response = sdk.lockOperations().getLocksForUser(LOCK_ID)

Java

// Returns a CompletableFuture<LockUserResponse>
var response = sdk.lockOperations().getLocksForUserAsync(LOCK_ID);

Swift

// Returns a LockUserResponse asynchronously
let response = await sdk.lockOperations().getLocksForUser(lockId: LOCK_ID)

JavaScript

// Returns a Promise<LockUserResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getLocksForUser("LOCK_ID");

C#

// Returns a Task<LockUserResponse>
var response = await sdk.GetLockOperations().GetLocksForUser(LOCK_ID);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_locks_for_user("LOCK_ID")

Update lock name

Kotlin

// Returns Unit
sdk.lockOperations().updateLockName(
  lockId = LOCK_ID, 
  name = "LOCK_NAME"
)

Java

// Returns a CompletableFuture<Void>
sdk.lockOperations().updateLockNameAsync(LOCK_ID, "LOCK_NAME");

Swift

// Returns Void asynchronously
await sdk.lockOperations().updateLockName(
  lockId: LOCK_ID, 
  name: "LOCK_NAME"
)

JavaScript

// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateLockName(
  "LOCK_ID", 
  "LOCK_NAME"
);

C#

// Returns a Task<object>
await sdk.GetLockOperations().UpdateLockName(
  lockId: LOCK_ID, 
  name: "LOCK_NAME"
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_lock_name(
  "LOCK_ID", 
  "LOCK_NAME"
)

Update lock favourite

Kotlin

// Returns Unit
sdk.lockOperations().updateLockFavourite(
  lockId = LOCK_ID,
  favourite = true
)

Java

// Returns a CompletableFuture<Void>
sdk.lockOperations().updateLockFavouriteAsync(LOCK_ID, true);

Swift

// Returns Void asynchronously
await sdk.lockOperations().updateLockFavourite(
  lockId: LOCK_ID, 
  favourite: true
)

JavaScript

// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateLockFavourite(
  "LOCK_ID", 
  true
);

C#

// Returns a Task<object>
await sdk.GetLockOperations().UpdateLockFavourite(
  lockId: LOCK_ID, 
  favourite: true
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_lock_favourite(
  "LOCK_ID", 
  True
)

Update lock setting default name

Kotlin

// Returns Unit
sdk.lockOperations().updateLockSettingDefaultName(
  lockId = LOCK_ID, 
  name = LOCK_NAME
)

Java

// Returns a CompletableFuture<Void>
sdk.lockOperations().updateLockSettingDefaultNameAsync(LOCK_ID, LOCK_NAME);

Swift

// Returns Void asynchronously
await sdk.lockOperations().updateLockSettingDefaultName(
  lockId: LOCK_ID, 
  name: "LOCK_NAME"
)

JavaScript

// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateLockSettingDefaultName(
  "LOCK_ID", 
  "LOCK_NAME"
);

C#

// Returns a Task<object>
await sdk.GetLockOperations().UpdateLockSettingDefaultName(
  lockId: LOCK_ID, 
  name: LOCK_NAME
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_lock_setting_default_name(
  "LOCK_ID", 
  "LOCK_NAME"
)

Set lock setting permitted addresses

Kotlin

// Returns Unit
sdk.lockOperations().setLockSettingPermittedAddresses(
  lockId = LOCK_ID,
  permittedAddresses = listOf(PERMITTED_ADDRESS)
)

Java

// Returns a CompletableFuture<Void>
sdk.lockOperations().setLockSettingPermittedAddressesAsync(LOCK_ID, List.of(PERMITTED_ADDRESS));

Swift

// Returns Void asynchronously
await sdk.lockOperations().setLockSettingPermittedAddresses(
  lockId: LOCK_ID, 
  permittedAddresses: [PERMITTED_ADDRESS]
)

JavaScript

// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().setLockSettingPermittedAddresses(
  "LOCK_ID", 
  ["PERMITTED_ADDRESS"]
);

C#

// Returns a Task<object>
await sdk.GetLockOperations().SetLockSettingPermittedAddresses(
  lockId: LOCK_ID, 
  permittedAddresses: [PERMITTED_ADDRESS]
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.set_lock_setting_permitted_addresses(
  "LOCK_ID", 
  ["PERMITTED_ADDRESS"]
)

Update lock setting hidden

Kotlin

// Returns Unit
sdk.lockOperations().updateLockSettingHidden(
  lockId = LOCK_ID,
  hidden = true
)

Java

// Returns a CompletableFuture<Void>
sdk.lockOperations().updateLockSettingHiddenAsync(LOCK_ID, true);

Swift

// Returns Void asynchronously
await sdk.lockOperations().updateLockSettingHidden(
  lockId: LOCK_ID, 
  hidden: true
)

JavaScript

// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateLockSettingHidden(
  "LOCK_ID", 
  true
);

C#

// Returns a Task<object>
await sdk.GetLockOperations().UpdateLockSettingHidden(
  lockId: LOCK_ID, 
  hidden: true
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_lock_setting_hidden(
  "LOCK_ID", 
  True
)

Set lock setting time restrictions

Kotlin

val timeRequirement = LockOperations.TimeRequirement.Builder()
  .setStart(START)
  .setEnd(END)
  .setTimezone(TIMEZONE_ID)
  .setDays(EnumSet.of(DayOfWeek.MONDAY))
  .build()
// Returns Unit
sdk.lockOperations().setLockSettingTimeRestrictions(
  lockId = LOCK_ID, 
  times = listOf(timeRequirements)
)

Java

var timeRequirement = new LockOperations.TimeRequirement.Builder()
    .setStart(START)
    .setEnd(END)
    .setTimezone(TIMEZONE_ID)
    .setDays(EnumSet.of(DayOfWeek.MONDAY))
    .build();
// Returns a CompletableFuture<Void>
sdk.lockOperations().setLockSettingTimeRestrictionsAsync(LOCK_ID, List.of(timeRequirement));

Swift

let timeRequirement = LockOperations.TimeRequirementBuilder()
    .setStart(start: START)
    .setEnd(end: END)
    .setTimezone(timezone: TIMEZONE_ID)
    .setDays(days: [DayOfWeek.monday])
    .build()
// Returns Void asynchronously
await sdk.lockOperations().setLockSettingTimeRestrictions(
  lockId: LOCK_ID, 
  times: [timeRequirement]
)

JavaScript

const timeRequirement = new com.doordeck.multiplatform.sdk.model.data.LockOperations.TimeRequirement.Builder()
  .setStart("START_HH_MM")
  .setEnd("END_HH_MM")
  .setTimezone("TIMEZONE")
  .setDays(new Set("MONDAY"))
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().setLockSettingTimeRestrictions(
  "LOCK_ID",
  [timeRequirement]
);

C#

var timeRequirement = new TimeRequirement(
  start: START, 
  end: END, 
  timezone: TIMEZONE, 
  days: [DayOfWeek.MONDAY]
);
// Returns Task<object>
await sdk.GetLockOperations().SetLockSettingTimeRestrictions(
  lockId: LOCK_ID, 
  times: [timeRequirement]
);

Python

timeRequirement = doordeck_headless_sdk.TimeRequirement(
  "START_HH_MM", 
  "END_HH_MM", 
  "TIMEZONE", 
  ["MONDAY"]
)
# Returns a Future[SimpleNamespace]
await sdk.lockOperations.set_lock_setting_time_restrictions(
  "LOCK_ID", 
  [timeRequirement]
)

Update lock setting location restrictions

Kotlin

val locationRequirement = LockOperations.LocationRequirement.Builder()
  .setLatitude(LATITUDE)
  .setLongitude(LONGITUDE)
  .setEnabled(true)
  .build()
// Returns Unit
sdk.lockOperations().updateLockSettingLocationRestrictions(
  lockId = LOCK_ID,
  location = locationRequirement
)

Java

var locationRequirement = new LockOperations.LocationRequirement.Builder()
  .setLatitude(LATITUDE)
  .setLongitude(LONGITUDE)
  .setEnabled(true)
  .build();
// Returns a CompletableFuture<Void>
sdk.lockOperations().updateLockSettingLocationRestrictionsAsync(LOCK_ID, locationRequirement);

Swift

let locationRequirement = LockOperations.LocationRequirementBuilder()
  .setLatitude(latitude: LATITUDE)
  .setLongitude(longitude: LONGITUDE)
  .setEnabled(enabled: true)
  .build()
// Returns Void asynchronously
await sdk.lockOperations().updateLockSettingLocationRestrictions(
  lockId: LOCK_ID,
  location: locationRequirement
)

JavaScript

const locationRequirement = new com.doordeck.multiplatform.sdk.model.data.LockOperations.LocationRequirement.Builder()
  .setLatitude(LATITUDE)
  .setLongitude(LONGITUDE)
  .setEnabled(ENABLED)
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateLockSettingLocationRestrictions(
  "LOCK_ID", 
  locationRequirement
);

C#

var locationRequirement = new LocationRequirement(
  latitude: LATITUDE, 
  longitude: LONGITUDE, 
  enabled: true
);
// Returns a Task<object>
await sdk.GetLockOperations().UpdateLockSettingLocationRestrictions(
  lockId: LOCK_ID, 
  location: locationRequirement
);

Python

locationRequirement = doordeck_headless_sdk.LocationRequirement(
  LATITUDE, 
  LONGITUDE, 
  True
)
# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_lock_setting_location_restrictions(
  "LOCK_ID", 
  locationRequirement
)

Get a Sentry Interactive user's public key

warning

This function is only available to users with Sentry Interactive issued auth tokens

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKey(
  userEmail = "USER_EMAIL", 
  visitor = false
)

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyAsync("USER_EMAIL", false);

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKey(
  userEmail: "USER_EMAIL", 
  visitor: false
)

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKey(
  "USER_EMAIL", 
  false
);

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKey(
  userEmail: "USER_EMAIL", 
  visitor: false
);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key(
  "USER_EMAIL", 
  False
)

Lookup user public key by email

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKeyByEmail("USER_EMAIL")

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyByEmailAsync("USER_EMAIL");

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByEmail(email: "USER_EMAIL")

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByEmail("USER_EMAIL");

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKeyByEmail("USER_EMAIL");

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_email("USER_EMAIL")

Lookup user public key by telephone

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKeyByTelephone("USER_TELEPHONE")

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyByTelephoneAsync("USER_TELEPHONE");

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByTelephone(telephone: "USER_TELEPHONE")

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByTelephone("USER_TELEPHONE");

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKeyByTelephone("USER_TELEPHONE");

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_telephone("USER_TELEPHONE")

Lookup user public key by local key

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKeyByLocalKey("USER_LOCAL_KEY")

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyByLocalKeyAsync("USER_LOCAL_KEY");

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByLocalKey(localKey: "USER_LOCAL_KEY")

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByLocalKey("USER_LOCAL_KEY");

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKeyByLocalKey("USER_LOCAL_KEY");

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_local_key("USER_LOCAL_KEY")

Lookup user public key by foreign key

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKeyByForeignKey("USER_FOREIGN_KEY")

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyByForeignKeyAsync("USER_FOREIGN_KEY");

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByForeignKey(foreignKey: "USER_FOREIGN_KEY")

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByForeignKey("USER_FOREIGN_KEY");

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKeyByForeignKey("USER_FOREIGN_KEY");

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_foreign_key("USER_FOREIGN_KEY")

Lookup user public key by identity

Kotlin

// Returns a UserPublicKeyResponse
val response = sdk.lockOperations().getUserPublicKeyByIdentity("USER_IDENTITY")

Java

// Returns a CompletableFuture<UserPublicKeyResponse>
var response = sdk.lockOperations().getUserPublicKeyByIdentityAsync("USER_IDENTITY");

Swift

// Returns a UserPublicKeyResponse asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByIdentity(identity: "USER_IDENTITY")

JavaScript

// Returns a Promise<UserPublicKeyResponse>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByIdentity("USER_IDENTITY");

C#

// Returns a Task<UserPublicKeyResponse>
var response = await sdk.GetLockOperations().GetUserPublicKeyByIdentity("USER_IDENTITY");

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_identity("USER_IDENTITY")

Batch lookup user public key by email

Kotlin

// Returns a List<BatchUserPublicKeyResponse>
val response = sdk.lockOperations().getUserPublicKeyByEmails(listOf("USER_EMAIL", "USER_EMAIL"))

Java

// Returns a CompletableFuture<List<BatchUserPublicKeyResponse>>
var response = sdk.lockOperations().getUserPublicKeyByEmailsAsync(List.of("USER_EMAIL", "USER_EMAIL"));

Swift

// Returns a Array<BatchUserPublicKeyResponse> asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByEmails(emails: ["USER_EMAIL", "USER_EMAIL"])

JavaScript

// Returns a Promise<Array<BatchUserPublicKeyResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByEmails(["USER_EMAIL", "USER_EMAIL"]);

C#

// Returns a Task<List<BatchUserPublicKeyResponse>>
var response = await sdk.GetLockOperations().GetUserPublicKeyByEmails(["USER_EMAIL", "USER_EMAIL"]);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_emails(["USER_EMAIL", "USER_EMAIL"])

Batch lookup user public key by telephone

Kotlin

// Returns a List<BatchUserPublicKeyResponse>
val response = sdk.lockOperations().getUserPublicKeyByTelephones(listOf("USER_TELEPHONE", "USER_TELEPHONE"))

Java

// Returns a CompletableFuture<List<BatchUserPublicKeyResponse>>
var response = sdk.lockOperations().getUserPublicKeyByTelephonesAsync(List.of("USER_TELEPHONE", "USER_TELEPHONE"));

Swift

// Returns a Array<BatchUserPublicKeyResponse> asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByTelephones(telephones: ["USER_TELEPHONE", "USER_TELEPHONE"])

JavaScript

// Returns a Promise<Array<BatchUserPublicKeyResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByTelephones(["USER_TELEPHONE", "USER_TELEPHONE"]);

C#

// Returns a Task<List<BatchUserPublicKeyResponse>>
var response = await sdk.GetLockOperations().GetUserPublicKeyByTelephones(["USER_TELEPHONE", "USER_TELEPHONE"]);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_telephones(["USER_TELEPHONE", "USER_TELEPHONE"])

Batch lookup user public key by local key

Kotlin

// Returns a List<BatchUserPublicKeyResponse>
val response = sdk.lockOperations().getUserPublicKeyByLocalKeys(listOf("USER_LOCAL_KEY"))

Java

// Returns a CompletableFuture<List<BatchUserPublicKeyResponse>>
var response = sdk.lockOperations().getUserPublicKeyByLocalKeysAsync(List.of("USER_LOCAL_KEY"));

Swift

// Returns a Array<BatchUserPublicKeyResponse> asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByLocalKeys(localKeys: ["USER_LOCAL_KEY", "USER_LOCAL_KEY"])

JavaScript

// Returns a Promise<List<BatchUserPublicKeyResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByLocalKeys(["USER_LOCAL_KEY", "USER_LOCAL_KEY"]);

C#

// Returns a Task<List<BatchUserPublicKeyResponse>>
var response = await sdk.GetLockOperations().GetUserPublicKeyByLocalKeys(["USER_LOCAL_KEY", "USER_LOCAL_KEY"]);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_local_keys(["USER_LOCAL_KEY", "USER_LOCAL_KEY"])

Batch lookup user public key by foreign key

Kotlin

// Returns a List<BatchUserPublicKeyResponse>
val response = sdk.lockOperations().getUserPublicKeyByForeignKeys(listOf("USER_FOREIGN_KEY", "USER_FOREIGN_KEY"))

Java

// Returns a CompletableFuture<List<BatchUserPublicKeyResponse>>
var response = sdk.lockOperations().getUserPublicKeyByForeignKeysAsync(List.of("USER_FOREIGN_KEY", "USER_FOREIGN_KEY"));

Swift

// Returns a Array<BatchUserPublicKeyResponse> asynchronously
let response = await sdk.lockOperations().getUserPublicKeyByForeignKeys(foreignKeys: ["USER_FOREIGN_KEY", "USER_FOREIGN_KEY"])

JavaScript

// Returns a Promise<Array<BatchUserPublicKeyResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getUserPublicKeyByForeignKey(["USER_FOREIGN_KEY", "USER_FOREIGN_KEY"]);

C#

// Returns a Task<List<BatchUserPublicKeyResponse>>
var response = await sdk.GetLockOperations().GetUserPublicKeyByForeignKeys(["USER_FOREIGN_KEY", "USER_FOREIGN_KEY"]);

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_user_public_key_by_foreign_keys(["USER_FOREIGN_KEY", "USER_FOREIGN_KEY"])

Unlock

info

This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val unlockOperation = LockOperations.UnlockOperation.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .build()
// Returns Unit
sdk.lockOperations().unlock(unlockOperation)

Java

var unlockOperation = new LockOperations.UnlockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .build();
// Returns CompletableFuture<Void>
sdk.lockOperations().unlockAsync(unlockOperation);

Swift

let unlockOperation = LockOperations.UnlockOperationBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .build()
// Returns Void asynchronously
await sdk.lockOperations().unlock(unlockOperation: unlockOperation)

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const unlockOperation = new LockOperations.UnlockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().unlock(unlockOperation);

C#

// Returns a Task<object>
await sdk.GetLockOperations().Unlock(new UnlockOperation(new BaseOperation(LOCK_ID)));

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.unlock(
  doordeck_headless_sdk.UnlockOperation(
    doordeck_headless_sdk.BaseOperation("LOCK_ID")
  )
)

Share lock

info

This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val shareLockOperation = LockOperations.ShareLockOperation.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setShareLock(ShareLock.Builder()
    .setTargetUserId(TARGET_USER_ID)
    .setTargetUserRole(TARGET_USER_ROLE)
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build())
  .build()
// Returns Unit
sdk.lockOperations().shareLock(shareLockOperation)

Java

var shareLockOperation = new LockOperations.ShareLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setShareLock(new LockOperations.ShareLock.Builder()
    .setTargetUserId(TARGET_USER_ID)
    .setTargetUserRole(TARGET_USER_ROLE)
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build())
  .build();
// Returns a CompletableFuture<Void>
sdk.lockOperations().shareLockAsync(shareLockOperation);

Swift

let shareLockOperation = LockOperations.ShareLockOperationBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .setShareLock(shareLock: LockOperations.ShareLockBuilder()
    .setTargetUserId(targetUserId: TARGET_USER_ID)
    .setTargetUserRole(targetUserRole: TARGET_USER_ROLE)
    .setTargetUserPublicKey(targetUserPublicKey: TARGET_PUBLIC_KEY)
    .build())
  .build()
// Returns Void asynchronously  
await sdk.lockOperations().shareLock(shareLockOperation: shareLockOperation)

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const shareLockOperation = new LockOperations.ShareLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .setShareLock(new LockOperations.ShareLock.Builder()
    .setTargetUserId("TARGET_USER_ID")
    .setTargetUserRole("TARGET_USER_ROLE")
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build())
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().shareLock(shareLockOperation);

C#

// Returns Task<object>
await sdk.GetLockOperations().ShareLock(
  new ShareLockOperation(
    baseOperation: new BaseOperation(LOCK_ID), 
    shareLock: new ShareLock(
      targetUserId: TARGET_USER_ID, 
      targetUserRole: TARGET_USER_ROLE, 
      targetUserPublicKey: TARGET_PUBLIC_KEY
    )
  )
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.share_lock(
  doordeck_headless_sdk.ShareLockOperation(
    doordeck_headless_sdk.BaseOperation("LOCK_ID"),
    doordeck_headless_sdk.ShareLock(
      "TARGET_USER_ID", 
      "TARGET_USER_ROLE", 
      "BASE64_TARGET_PUBLIC_KEY"
    )
  )
)

Batch share lock

info

• This functionality requires the device to support the batch sharing feature. The function will retrieve the device's capabilities, store them in a cache, and perform the batch operation if supported. Otherwise, it will default to the standard device sharing process.
• This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val batchShareLockOperation = LockOperations.BatchShareLockOperation.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUsers(listOf(ShareLock.Builder()
    .setTargetUserId(TARGET_USER_ID)
    .setTargetUserRole(TARGET_USER_ROLE)
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build()))
  .build()
// Returns Unit
sdk.lockOperations().batchShareLock(batchShareLockOperation)

Java

var batchShareLockOperation = new LockOperations.BatchShareLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUsers(List.of(new LockOperations.ShareLock.Builder()
    .setTargetUserId(TARGET_USER_ID)
    .setTargetUserRole(TARGET_USER_ROLE)
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build()))
  .build();
// Returns a CompletableFuture<Void>
sdk.lockOperations().batchShareLockAsync(batchShareLockOperation);

Swift

let batchShareLockOperation = LockOperations.BatchShareLockOperationBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .setUsers(users: [LockOperations.ShareLockBuilder()
    .setTargetUserId(targetUserId: TARGET_USER_ID)
    .setTargetUserRole(targetUserRole: TARGET_USER_ROLE)
    .setTargetUserPublicKey(targetUserPublicKey: TARGET_PUBLIC_KEY)
    .build()])
  .build()
// Returns Void asynchronously  
await sdk.lockOperations().batchShareLock(batchShareLockOperation: batchShareLockOperation)

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const batchShareLockOperation = new LockOperations.BatchShareLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .setUsers([new LockOperations.ShareLock.Builder()
    .setTargetUserId("TARGET_USER_ID")
    .setTargetUserRole("TARGET_USER_ROLE")
    .setTargetUserPublicKey(TARGET_PUBLIC_KEY)
    .build()])
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().batchShareLock(batchShareLockOperation);

C#

// Returns Task<object>
await sdk.GetLockOperations().BatchShareLock(
    new BatchShareLockOperation(
        baseOperation: new BaseOperation(LOCK_ID), 
        users: [new ShareLock(
          targetUserId: TARGET_USER_ID, 
          targetUserRole: TARGET_USER_ROLE, 
          targetUserPublicKey: TARGET_PUBLIC_KEY
        )]
    )
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.batch_share_lock(
  doordeck_headless_sdk.BatchShareLockOperation(
    doordeck_headless_sdk.BaseOperation("LOCK_ID"),
    [doordeck_headless_sdk.ShareLock(
      "TARGET_USER_ID",
      "TARGET_USER_ROLE",
      "BASE64_TARGET_PUBLIC_KEY"
    )]
  )
)

Revoke access to lock

info

This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val revokeAccessToLockOperation = LockOperations.RevokeAccessToLockOperation.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUsers(listOf(USER_ID))
  .build()
// Returns Unit
sdk.lockOperations().revokeAccessToLock(revokeAccessToLockOperation)

Java

var revokeAccessToLockOperation = new LockOperations.RevokeAccessToLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUsers(List.of(USER_ID))
  .build();
// Returns Unit
sdk.lockOperations().revokeAccessToLockAsync(revokeAccessToLockOperation);

Swift

let revokeAccessToLockOperation = LockOperations.RevokeAccessToLockOperationBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .setUsers(users: [USER_ID])
  .build()
// Returns Void asynchronously
await sdk.lockOperations().revokeAccessToLock(revokeAccessToLockOperation: revokeAccessToLockOperation)

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const revokeAccessToLockOperation = new LockOperations.RevokeAccessToLockOperation.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .setUsers(["USER_ID"])
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().revokeAccessToLock(revokeAccessToLockOperation);

C#

// Returns Task<object>
await sdk.GetLockOperations().RevokeAccessToLock(
  new RevokeAccessToLockOperation(
    baseOperation: new BaseOperation(LOCK_ID), 
    users: [USER_ID]
  )
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.revoke_access_to_lock(
  doordeck_headless_sdk.RevokeAccessToLockOperation(
    doordeck_headless_sdk.BaseOperation("LOCK_ID"),
    ["USER_ID"]
  )
)

Update secure setting unlock duration

info

This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val updateSecureSettingUnlockDuration = LockOperations.UpdateSecureSettingUnlockDuration.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUnlockDuration(UNLOCK_DURATION)
  .build()
// Returns Unit
sdk.lockOperations().updateSecureSettingUnlockDuration(updateSecureSettingUnlockDuration)

Java

var updateSecureSettingUnlockDuration = new LockOperations.UpdateSecureSettingUnlockDuration.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUnlockDuration(UNLOCK_DURATION)
  .build();
// Returns Unit
sdk.lockOperations().updateSecureSettingUnlockDurationAsync(updateSecureSettingUnlockDuration);

Swift

let updateSecureSettingUnlockDuration = LockOperations.UpdateSecureSettingUnlockDurationBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .setUnlockDuration(unlockDuration: UNLOCK_DURATION)
  .build();
// Returns Void asynchronously
await sdk.lockOperations().updateSecureSettingUnlockDuration(updateSecureSettingUnlockDuration: updateSecureSettingUnlockDuration)

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const updateSecureSettingUnlockDuration = new LockOperations.UpdateSecureSettingUnlockDuration.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .setUnlockDuration(UNLOCK_DURATION)
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateSecureSettingUnlockDuration(updateSecureSettingUnlockDuration);

C#

// Returns Task<object>
await sdk.GetLockOperations().UpdateSecureSettingUnlockDuration(
  new UpdateSecureSettingUnlockDuration(
    baseOperation: new BaseOperation(LOCK_ID), 
    unlockDuration: UNLOCK_DURATION
  )
);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_secure_setting_unlock_duration(
  doordeck_headless_sdk.UpdateSecureSettingUnlockDuration(
    doordeck_headless_sdk.BaseOperation("LOCK_ID"),
    UNLOCK_DURATION
  )
)

Update secure setting unlock between

info

This function can also be used by passing all the necessary parameters to it, such as the user ID, certificate chain, and private key. In the next example, we are using these values from the context and hence we do not need to pass them.

Kotlin

val updateSecureSettingUnlockBetween = LockOperations.UpdateSecureSettingUnlockBetween.Builder()
  .setBaseOperation(LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUnlockBetween(LockOperations.UnlockBetween.Builder()
    .setStart(START)
    .setEnd(END)
    .setTimezone(TIMEZONE)
    .setDays(listOf(DayOfWeek.MONDAY))
    .build())
  .build()
// Returns Unit
sdk.lockOperations().updateSecureSettingUnlockBetween(updateSecureSettingUnlockBetween)

Java

var updateSecureSettingUnlockBetween = new LockOperations.UpdateSecureSettingUnlockBetween.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId(LOCK_ID)
    .build())
  .setUnlockBetween(new LockOperations.UnlockBetween.Builder()
    .setStart(START)
    .setEnd(END)
    .setTimezone(TIMEZONE)
    .setDays(List.of(DayOfWeek.MONDAY))
    .build())
  .build();
// Returns Unit
updateSecureSettingUnlockBetweenAsync(updateSecureSettingUnlockBetween);

Swift

let updateSecureSettingUnlockBetween = LockOperations.UpdateSecureSettingUnlockBetweenBuilder()
  .setBaseOperation(baseOperation: LockOperations.BaseOperationBuilder()
    .setLockId(lockId: LOCK_ID)
    .build())
  .setUnlockBetween(unlockBetween: LockOperations.UnlockBetweenBuilder()
    .setStart(start: START)
    .setEnd(end: END)
    .setTimezone(timezone: TIMEZONE_ID)
    .setDays(days: [DayOfWeek.monday])
    .build())
  .build()
// Returns Void asynchronously
await sdk.lockOperations().updateSecureSettingUnlockBetween(updateSecureSettingUnlockBetween: updateSecureSettingUnlockBetween);

JavaScript

const LockOperations = com.doordeck.multiplatform.sdk.model.data.LockOperations;
const updateSecureSettingUnlockBetween = new LockOperations.UpdateSecureSettingUnlockBetween.Builder()
  .setBaseOperation(new LockOperations.BaseOperation.Builder()
    .setLockId("LOCK_ID")
    .build())
  .setUnlockBetween(new LockOperations.UnlockBetween.Builder()
    .setStart("START_HH_MM")
    .setEnd("END_HH_MM")
    .setTimezone("TIMEZONE")
    .setDays(new Set("MONDAY"))
    .build())
  .build();
// Returns a Promise<any>
await com.doordeck.multiplatform.sdk.api.lockOperations().updateSecureSettingUnlockBetween(updateSecureSettingUnlockBetween);

C#

var unlockBetween = new UpdateSecureSettingUnlockBetween(
    baseOperation: new BaseOperation(LOCK_ID),
    unlockBetween: new UnlockBetween(
        start: START,
        end: END,
        timezone: TIMEZONE,
        days: [DayOfWeek.FRIDAY]
    )
);
// Returns Task<object>
await sdk.GetLockOperations().UpdateSecureSettingUnlockBetween(unlockBetween);

Python

# Returns a Future[SimpleNamespace]
await sdk.lockOperations.update_secure_setting_unlock_between(
  doordeck_headless_sdk.UpdateSecureSettingUnlockBetween(
    doordeck_headless_sdk.BaseOperation("LOCK_ID"),
    doordeck_headless_sdk.UnlockBetween(
      "START_HH_MM", 
      "END_HH_MM", 
      "TIMEZONE",
      ["MONDAY"]
    )
  )
)

Get pinned locks

Kotlin

// Returns List<LockResponse>
val response = sdk.lockOperations().getPinnedLocks()

Java

// Returns a CompletableFuture<List<LockResponse>>
var response = sdk.lockOperations().getPinnedLocksAsync();

Swift

// Returns a Array<LockResponse> asynchronously
let response = await sdk.lockOperations().getPinnedLocks()

JavaScript

// Returns a Promise<Array<LockResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getPinnedLocks();

C#

// Returns a Task<List<LockResponse>>
var response = await sdk.GetLockOperations().GetPinnedLocks();

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_pinned_locks()

Get shareable locks

Kotlin

// Returns a List<ShareableLockResponse>
val response = sdk.lockOperations().getShareableLocks()

Java

// Returns a CompletableFuture<List<ShareableLockResponse>>
var response = sdk.lockOperations().getShareableLocksAsync();

Swift

// Returns a Array<ShareableLockResponse> asynchronously
let response = await sdk.lockOperations().getShareableLocks()

JavaScript

// Returns a Promise<Array<ShareableLockResponse>>
const response = await com.doordeck.multiplatform.sdk.api.lockOperations().getShareableLocks();

C#

// Returns a Task<List<ShareableLockResponse>>
var response = await sdk.GetLockOperations().GetShareableLocks();

Python

# Returns a Future[SimpleNamespace]
response = await sdk.lockOperations.get_shareable_locks()