#![allow(non_snake_case)]
use anyhow;
use reqwest::*;
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryAlias {
#[serde(rename = "alias")]
pub alias_: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "primaryEmail")]
pub primaryEmail: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryAliases {
#[serde(rename = "aliases")]
pub aliases: Option<Vec<Value>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryAsp {
#[serde(rename = "codeId")]
pub codeId: Option<i32>,
#[serde(rename = "creationTime")]
pub creationTime: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "lastTimeUsed")]
pub lastTimeUsed: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "userKey")]
pub userKey: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryAsps {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryAsp>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryAuxiliaryMessage {
#[serde(rename = "auxiliaryMessage")]
pub auxiliaryMessage: Option<String>,
#[serde(rename = "fieldMask")]
pub fieldMask: Option<String>,
#[serde(rename = "severity")]
pub severity: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBacklightInfo {
#[serde(rename = "brightness")]
pub brightness: Option<i32>,
#[serde(rename = "maxBrightness")]
pub maxBrightness: Option<i32>,
#[serde(rename = "path")]
pub path: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchChangeChromeOsDeviceStatusRequest {
#[serde(rename = "changeChromeOsDeviceStatusAction")]
pub changeChromeOsDeviceStatusAction: Option<String>,
#[serde(rename = "deprovisionReason")]
pub deprovisionReason: Option<String>,
#[serde(rename = "deviceIds")]
pub deviceIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchChangeChromeOsDeviceStatusResponse {
#[serde(rename = "changeChromeOsDeviceStatusResults")]
pub changeChromeOsDeviceStatusResults: Option<Vec<DirectoryChangeChromeOsDeviceStatusResult>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchCreatePrintServersRequest {
#[serde(rename = "requests")]
pub requests: Option<Vec<DirectoryCreatePrintServerRequest>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchCreatePrintServersResponse {
#[serde(rename = "failures")]
pub failures: Option<Vec<DirectoryPrintServerFailureInfo>>,
#[serde(rename = "printServers")]
pub printServers: Option<Vec<DirectoryPrintServer>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchCreatePrintersRequest {
#[serde(rename = "requests")]
pub requests: Option<Vec<DirectoryCreatePrinterRequest>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchCreatePrintersResponse {
#[serde(rename = "failures")]
pub failures: Option<Vec<DirectoryFailureInfo>>,
#[serde(rename = "printers")]
pub printers: Option<Vec<DirectoryPrinter>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchDeletePrintServersRequest {
#[serde(rename = "printServerIds")]
pub printServerIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchDeletePrintServersResponse {
#[serde(rename = "failedPrintServers")]
pub failedPrintServers: Option<Vec<DirectoryPrintServerFailureInfo>>,
#[serde(rename = "printServerIds")]
pub printServerIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchDeletePrintersRequest {
#[serde(rename = "printerIds")]
pub printerIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBatchDeletePrintersResponse {
#[serde(rename = "failedPrinters")]
pub failedPrinters: Option<Vec<DirectoryFailureInfo>>,
#[serde(rename = "printerIds")]
pub printerIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBuilding {
#[serde(rename = "address")]
pub address: Option<DirectoryBuildingAddress>,
#[serde(rename = "buildingId")]
pub buildingId: Option<String>,
#[serde(rename = "buildingName")]
pub buildingName: Option<String>,
#[serde(rename = "coordinates")]
pub coordinates: Option<DirectoryBuildingCoordinates>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "etags")]
pub etags: Option<String>,
#[serde(rename = "floorNames")]
pub floorNames: Option<Vec<String>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBuildingAddress {
#[serde(rename = "addressLines")]
pub addressLines: Option<Vec<String>>,
#[serde(rename = "administrativeArea")]
pub administrativeArea: Option<String>,
#[serde(rename = "languageCode")]
pub languageCode: Option<String>,
#[serde(rename = "locality")]
pub locality: Option<String>,
#[serde(rename = "postalCode")]
pub postalCode: Option<String>,
#[serde(rename = "regionCode")]
pub regionCode: Option<String>,
#[serde(rename = "sublocality")]
pub sublocality: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBuildingCoordinates {
#[serde(rename = "latitude")]
pub latitude: Option<f64>,
#[serde(rename = "longitude")]
pub longitude: Option<f64>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryBuildings {
#[serde(rename = "buildings")]
pub buildings: Option<Vec<DirectoryBuilding>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCalendarResource {
#[serde(rename = "buildingId")]
pub buildingId: Option<String>,
#[serde(rename = "capacity")]
pub capacity: Option<i32>,
#[serde(rename = "etags")]
pub etags: Option<String>,
#[serde(rename = "featureInstances")]
pub featureInstances: Option<Value>,
#[serde(rename = "floorName")]
pub floorName: Option<String>,
#[serde(rename = "floorSection")]
pub floorSection: Option<String>,
#[serde(rename = "generatedResourceName")]
pub generatedResourceName: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "resourceCategory")]
pub resourceCategory: Option<String>,
#[serde(rename = "resourceDescription")]
pub resourceDescription: Option<String>,
#[serde(rename = "resourceEmail")]
pub resourceEmail: Option<String>,
#[serde(rename = "resourceId")]
pub resourceId: Option<String>,
#[serde(rename = "resourceName")]
pub resourceName: Option<String>,
#[serde(rename = "resourceType")]
pub resourceType: Option<String>,
#[serde(rename = "userVisibleDescription")]
pub userVisibleDescription: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCalendarResources {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryCalendarResource>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChangeChromeOsDeviceStatusResult {
#[serde(rename = "deviceId")]
pub deviceId: Option<String>,
#[serde(rename = "error")]
pub error: Option<DirectoryStatus>,
#[serde(rename = "response")]
pub response: Option<DirectoryChangeChromeOsDeviceStatusSucceeded>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChangeChromeOsDeviceStatusSucceeded {}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChannel {
#[serde(rename = "address")]
pub address: Option<String>,
#[serde(rename = "expiration")]
pub expiration: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "params")]
pub params: Option<Value>,
#[serde(rename = "payload")]
pub payload: Option<bool>,
#[serde(rename = "resourceId")]
pub resourceId: Option<String>,
#[serde(rename = "resourceUri")]
pub resourceUri: Option<String>,
#[serde(rename = "token")]
pub token: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChromeOsDevice {
#[serde(rename = "activeTimeRanges")]
pub activeTimeRanges: Option<Vec<Value>>,
#[serde(rename = "annotatedAssetId")]
pub annotatedAssetId: Option<String>,
#[serde(rename = "annotatedLocation")]
pub annotatedLocation: Option<String>,
#[serde(rename = "annotatedUser")]
pub annotatedUser: Option<String>,
#[serde(rename = "autoUpdateExpiration")]
pub autoUpdateExpiration: Option<String>,
#[serde(rename = "autoUpdateThrough")]
pub autoUpdateThrough: Option<String>,
#[serde(rename = "backlightInfo")]
pub backlightInfo: Option<Vec<DirectoryBacklightInfo>>,
#[serde(rename = "bootMode")]
pub bootMode: Option<String>,
#[serde(rename = "chromeOsType")]
pub chromeOsType: Option<String>,
#[serde(rename = "cpuInfo")]
pub cpuInfo: Option<Vec<Value>>,
#[serde(rename = "cpuStatusReports")]
pub cpuStatusReports: Option<Vec<Value>>,
#[serde(rename = "deprovisionReason")]
pub deprovisionReason: Option<String>,
#[serde(rename = "deviceFiles")]
pub deviceFiles: Option<Vec<Value>>,
#[serde(rename = "deviceId")]
pub deviceId: Option<String>,
#[serde(rename = "deviceLicenseType")]
pub deviceLicenseType: Option<String>,
#[serde(rename = "diskVolumeReports")]
pub diskVolumeReports: Option<Vec<Value>>,
#[serde(rename = "dockMacAddress")]
pub dockMacAddress: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "ethernetMacAddress")]
pub ethernetMacAddress: Option<String>,
#[serde(rename = "ethernetMacAddress0")]
pub ethernetMacAddress0: Option<String>,
#[serde(rename = "extendedSupportEligible")]
pub extendedSupportEligible: Option<bool>,
#[serde(rename = "extendedSupportEnabled")]
pub extendedSupportEnabled: Option<bool>,
#[serde(rename = "extendedSupportStart")]
pub extendedSupportStart: Option<String>,
#[serde(rename = "fanInfo")]
pub fanInfo: Option<Vec<DirectoryFanInfo>>,
#[serde(rename = "firmwareVersion")]
pub firmwareVersion: Option<String>,
#[serde(rename = "firstEnrollmentTime")]
pub firstEnrollmentTime: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "lastDeprovisionTimestamp")]
pub lastDeprovisionTimestamp: Option<String>,
#[serde(rename = "lastEnrollmentTime")]
pub lastEnrollmentTime: Option<String>,
#[serde(rename = "lastKnownNetwork")]
pub lastKnownNetwork: Option<Vec<Value>>,
#[serde(rename = "lastSync")]
pub lastSync: Option<String>,
#[serde(rename = "macAddress")]
pub macAddress: Option<String>,
#[serde(rename = "manufactureDate")]
pub manufactureDate: Option<String>,
#[serde(rename = "meid")]
pub meid: Option<String>,
#[serde(rename = "model")]
pub model: Option<String>,
#[serde(rename = "notes")]
pub notes: Option<String>,
#[serde(rename = "orderNumber")]
pub orderNumber: Option<String>,
#[serde(rename = "orgUnitId")]
pub orgUnitId: Option<String>,
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
#[serde(rename = "osUpdateStatus")]
pub osUpdateStatus: Option<DirectoryOsUpdateStatus>,
#[serde(rename = "osVersion")]
pub osVersion: Option<String>,
#[serde(rename = "platformVersion")]
pub platformVersion: Option<String>,
#[serde(rename = "recentUsers")]
pub recentUsers: Option<Vec<Value>>,
#[serde(rename = "screenshotFiles")]
pub screenshotFiles: Option<Vec<Value>>,
#[serde(rename = "serialNumber")]
pub serialNumber: Option<String>,
#[serde(rename = "status")]
pub status: Option<String>,
#[serde(rename = "supportEndDate")]
pub supportEndDate: Option<String>,
#[serde(rename = "systemRamFreeReports")]
pub systemRamFreeReports: Option<Vec<Value>>,
#[serde(rename = "systemRamTotal")]
pub systemRamTotal: Option<String>,
#[serde(rename = "tpmVersionInfo")]
pub tpmVersionInfo: Option<Value>,
#[serde(rename = "willAutoRenew")]
pub willAutoRenew: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChromeOsDeviceAction {
#[serde(rename = "action")]
pub action: Option<String>,
#[serde(rename = "deprovisionReason")]
pub deprovisionReason: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChromeOsDevices {
#[serde(rename = "chromeosdevices")]
pub chromeosdevices: Option<Vec<DirectoryChromeOsDevice>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryChromeOsMoveDevicesToOu {
#[serde(rename = "deviceIds")]
pub deviceIds: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCreatePrintServerRequest {
#[serde(rename = "parent")]
pub parent: Option<String>,
#[serde(rename = "printServer")]
pub printServer: Option<DirectoryPrintServer>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCreatePrinterRequest {
#[serde(rename = "parent")]
pub parent: Option<String>,
#[serde(rename = "printer")]
pub printer: Option<DirectoryPrinter>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCustomer {
#[serde(rename = "alternateEmail")]
pub alternateEmail: Option<String>,
#[serde(rename = "customerCreationTime")]
pub customerCreationTime: Option<String>,
#[serde(rename = "customerDomain")]
pub customerDomain: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "language")]
pub language: Option<String>,
#[serde(rename = "phoneNumber")]
pub phoneNumber: Option<String>,
#[serde(rename = "postalAddress")]
pub postalAddress: Option<DirectoryCustomerPostalAddress>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryCustomerPostalAddress {
#[serde(rename = "addressLine1")]
pub addressLine1: Option<String>,
#[serde(rename = "addressLine2")]
pub addressLine2: Option<String>,
#[serde(rename = "addressLine3")]
pub addressLine3: Option<String>,
#[serde(rename = "contactName")]
pub contactName: Option<String>,
#[serde(rename = "countryCode")]
pub countryCode: Option<String>,
#[serde(rename = "locality")]
pub locality: Option<String>,
#[serde(rename = "organizationName")]
pub organizationName: Option<String>,
#[serde(rename = "postalCode")]
pub postalCode: Option<String>,
#[serde(rename = "region")]
pub region: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDirectoryChromeosdevicesCommand {
#[serde(rename = "commandExpireTime")]
pub commandExpireTime: Option<String>,
#[serde(rename = "commandId")]
pub commandId: Option<String>,
#[serde(rename = "commandResult")]
pub commandResult: Option<DirectoryDirectoryChromeosdevicesCommandResult>,
#[serde(rename = "issueTime")]
pub issueTime: Option<String>,
#[serde(rename = "payload")]
pub payload: Option<String>,
#[serde(rename = "state")]
pub state: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDirectoryChromeosdevicesCommandResult {
#[serde(rename = "commandResultPayload")]
pub commandResultPayload: Option<String>,
#[serde(rename = "errorMessage")]
pub errorMessage: Option<String>,
#[serde(rename = "executeTime")]
pub executeTime: Option<String>,
#[serde(rename = "result")]
pub result: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDirectoryChromeosdevicesIssueCommandRequest {
#[serde(rename = "commandType")]
pub commandType: Option<String>,
#[serde(rename = "payload")]
pub payload: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDirectoryChromeosdevicesIssueCommandResponse {
#[serde(rename = "commandId")]
pub commandId: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDomainAlias {
#[serde(rename = "creationTime")]
pub creationTime: Option<String>,
#[serde(rename = "domainAliasName")]
pub domainAliasName: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "parentDomainName")]
pub parentDomainName: Option<String>,
#[serde(rename = "verified")]
pub verified: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDomainAliases {
#[serde(rename = "domainAliases")]
pub domainAliases: Option<Vec<DirectoryDomainAlias>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDomains {
#[serde(rename = "creationTime")]
pub creationTime: Option<String>,
#[serde(rename = "domainAliases")]
pub domainAliases: Option<Vec<DirectoryDomainAlias>>,
#[serde(rename = "domainName")]
pub domainName: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "isPrimary")]
pub isPrimary: Option<bool>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "verified")]
pub verified: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryDomains2 {
#[serde(rename = "domains")]
pub domains: Option<Vec<DirectoryDomains>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryEmpty {}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFailureInfo {
#[serde(rename = "errorCode")]
pub errorCode: Option<String>,
#[serde(rename = "errorMessage")]
pub errorMessage: Option<String>,
#[serde(rename = "printer")]
pub printer: Option<DirectoryPrinter>,
#[serde(rename = "printerId")]
pub printerId: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFanInfo {
#[serde(rename = "speedRpm")]
pub speedRpm: Option<i32>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFeature {
#[serde(rename = "etags")]
pub etags: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFeatureInstance {
#[serde(rename = "feature")]
pub feature: Option<DirectoryFeature>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFeatureRename {
#[serde(rename = "newName")]
pub newName: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryFeatures {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "features")]
pub features: Option<Vec<DirectoryFeature>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryGroup {
#[serde(rename = "adminCreated")]
pub adminCreated: Option<bool>,
#[serde(rename = "aliases")]
pub aliases: Option<Vec<String>>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "directMembersCount")]
pub directMembersCount: Option<String>,
#[serde(rename = "email")]
pub email: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "nonEditableAliases")]
pub nonEditableAliases: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryGroupAlias {
#[serde(rename = "alias")]
pub alias_: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "primaryEmail")]
pub primaryEmail: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryGroups {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "groups")]
pub groups: Option<Vec<DirectoryGroup>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryListPrintServersResponse {
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
#[serde(rename = "printServers")]
pub printServers: Option<Vec<DirectoryPrintServer>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryListPrinterModelsResponse {
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
#[serde(rename = "printerModels")]
pub printerModels: Option<Vec<DirectoryPrinterModel>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryListPrintersResponse {
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
#[serde(rename = "printers")]
pub printers: Option<Vec<DirectoryPrinter>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMember {
#[serde(rename = "delivery_settings")]
pub delivery_settings: Option<String>,
#[serde(rename = "email")]
pub email: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "role")]
pub role: Option<String>,
#[serde(rename = "status")]
pub status: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMembers {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "members")]
pub members: Option<Vec<DirectoryMember>>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMembersHasMember {
#[serde(rename = "isMember")]
pub isMember: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMobileDevice {
#[serde(rename = "adbStatus")]
pub adbStatus: Option<bool>,
#[serde(rename = "applications")]
pub applications: Option<Vec<Value>>,
#[serde(rename = "basebandVersion")]
pub basebandVersion: Option<String>,
#[serde(rename = "bootloaderVersion")]
pub bootloaderVersion: Option<String>,
#[serde(rename = "brand")]
pub brand: Option<String>,
#[serde(rename = "buildNumber")]
pub buildNumber: Option<String>,
#[serde(rename = "defaultLanguage")]
pub defaultLanguage: Option<String>,
#[serde(rename = "developerOptionsStatus")]
pub developerOptionsStatus: Option<bool>,
#[serde(rename = "deviceCompromisedStatus")]
pub deviceCompromisedStatus: Option<String>,
#[serde(rename = "deviceId")]
pub deviceId: Option<String>,
#[serde(rename = "devicePasswordStatus")]
pub devicePasswordStatus: Option<String>,
#[serde(rename = "email")]
pub email: Option<Vec<String>>,
#[serde(rename = "encryptionStatus")]
pub encryptionStatus: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "firstSync")]
pub firstSync: Option<String>,
#[serde(rename = "hardware")]
pub hardware: Option<String>,
#[serde(rename = "hardwareId")]
pub hardwareId: Option<String>,
#[serde(rename = "imei")]
pub imei: Option<String>,
#[serde(rename = "kernelVersion")]
pub kernelVersion: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "lastSync")]
pub lastSync: Option<String>,
#[serde(rename = "managedAccountIsOnOwnerProfile")]
pub managedAccountIsOnOwnerProfile: Option<bool>,
#[serde(rename = "manufacturer")]
pub manufacturer: Option<String>,
#[serde(rename = "meid")]
pub meid: Option<String>,
#[serde(rename = "model")]
pub model: Option<String>,
#[serde(rename = "name")]
pub name: Option<Vec<String>>,
#[serde(rename = "networkOperator")]
pub networkOperator: Option<String>,
#[serde(rename = "os")]
pub os: Option<String>,
#[serde(rename = "otherAccountsInfo")]
pub otherAccountsInfo: Option<Vec<String>>,
#[serde(rename = "privilege")]
pub privilege: Option<String>,
#[serde(rename = "releaseVersion")]
pub releaseVersion: Option<String>,
#[serde(rename = "resourceId")]
pub resourceId: Option<String>,
#[serde(rename = "securityPatchLevel")]
pub securityPatchLevel: Option<String>,
#[serde(rename = "serialNumber")]
pub serialNumber: Option<String>,
#[serde(rename = "status")]
pub status: Option<String>,
#[serde(rename = "supportsWorkProfile")]
pub supportsWorkProfile: Option<bool>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "unknownSourcesStatus")]
pub unknownSourcesStatus: Option<bool>,
#[serde(rename = "userAgent")]
pub userAgent: Option<String>,
#[serde(rename = "wifiMacAddress")]
pub wifiMacAddress: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMobileDeviceAction {
#[serde(rename = "action")]
pub action: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryMobileDevices {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "mobiledevices")]
pub mobiledevices: Option<Vec<DirectoryMobileDevice>>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryOrgUnit {
#[serde(rename = "blockInheritance")]
pub blockInheritance: Option<bool>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "orgUnitId")]
pub orgUnitId: Option<String>,
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
#[serde(rename = "parentOrgUnitId")]
pub parentOrgUnitId: Option<String>,
#[serde(rename = "parentOrgUnitPath")]
pub parentOrgUnitPath: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryOrgUnits {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "organizationUnits")]
pub organizationUnits: Option<Vec<DirectoryOrgUnit>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryOsUpdateStatus {
#[serde(rename = "rebootTime")]
pub rebootTime: Option<String>,
#[serde(rename = "state")]
pub state: Option<String>,
#[serde(rename = "targetKioskAppVersion")]
pub targetKioskAppVersion: Option<String>,
#[serde(rename = "targetOsVersion")]
pub targetOsVersion: Option<String>,
#[serde(rename = "updateCheckTime")]
pub updateCheckTime: Option<String>,
#[serde(rename = "updateTime")]
pub updateTime: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrintServer {
#[serde(rename = "createTime")]
pub createTime: Option<String>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "orgUnitId")]
pub orgUnitId: Option<String>,
#[serde(rename = "uri")]
pub uri: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrintServerFailureInfo {
#[serde(rename = "errorCode")]
pub errorCode: Option<String>,
#[serde(rename = "errorMessage")]
pub errorMessage: Option<String>,
#[serde(rename = "printServer")]
pub printServer: Option<DirectoryPrintServer>,
#[serde(rename = "printServerId")]
pub printServerId: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrinter {
#[serde(rename = "auxiliaryMessages")]
pub auxiliaryMessages: Option<Vec<DirectoryAuxiliaryMessage>>,
#[serde(rename = "createTime")]
pub createTime: Option<String>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "makeAndModel")]
pub makeAndModel: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "orgUnitId")]
pub orgUnitId: Option<String>,
#[serde(rename = "uri")]
pub uri: Option<String>,
#[serde(rename = "useDriverlessConfig")]
pub useDriverlessConfig: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrinterModel {
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "makeAndModel")]
pub makeAndModel: Option<String>,
#[serde(rename = "manufacturer")]
pub manufacturer: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrivilege {
#[serde(rename = "childPrivileges")]
pub childPrivileges: Option<Vec<DirectoryPrivilege>>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "isOuScopable")]
pub isOuScopable: Option<bool>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "privilegeName")]
pub privilegeName: Option<String>,
#[serde(rename = "serviceId")]
pub serviceId: Option<String>,
#[serde(rename = "serviceName")]
pub serviceName: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryPrivileges {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryPrivilege>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryRole {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "isSuperAdminRole")]
pub isSuperAdminRole: Option<bool>,
#[serde(rename = "isSystemRole")]
pub isSystemRole: Option<bool>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "roleDescription")]
pub roleDescription: Option<String>,
#[serde(rename = "roleId")]
pub roleId: Option<String>,
#[serde(rename = "roleName")]
pub roleName: Option<String>,
#[serde(rename = "rolePrivileges")]
pub rolePrivileges: Option<Vec<Value>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryRoleAssignment {
#[serde(rename = "assignedTo")]
pub assignedTo: Option<String>,
#[serde(rename = "assigneeType")]
pub assigneeType: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "orgUnitId")]
pub orgUnitId: Option<String>,
#[serde(rename = "roleAssignmentId")]
pub roleAssignmentId: Option<String>,
#[serde(rename = "roleId")]
pub roleId: Option<String>,
#[serde(rename = "scopeType")]
pub scopeType: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryRoleAssignments {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryRoleAssignment>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryRoles {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryRole>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectorySchema {
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "fields")]
pub fields: Option<Vec<DirectorySchemaFieldSpec>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "schemaId")]
pub schemaId: Option<String>,
#[serde(rename = "schemaName")]
pub schemaName: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectorySchemaFieldSpec {
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "fieldId")]
pub fieldId: Option<String>,
#[serde(rename = "fieldName")]
pub fieldName: Option<String>,
#[serde(rename = "fieldType")]
pub fieldType: Option<String>,
#[serde(rename = "indexed")]
pub indexed: Option<bool>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "multiValued")]
pub multiValued: Option<bool>,
#[serde(rename = "numericIndexingSpec")]
pub numericIndexingSpec: Option<Value>,
#[serde(rename = "readAccessType")]
pub readAccessType: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectorySchemas {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "schemas")]
pub schemas: Option<Vec<DirectorySchema>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryStatus {
#[serde(rename = "code")]
pub code: Option<i32>,
#[serde(rename = "details")]
pub details: Option<Vec<Value>>,
#[serde(rename = "message")]
pub message: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryToken {
#[serde(rename = "anonymous")]
pub anonymous: Option<bool>,
#[serde(rename = "clientId")]
pub clientId: Option<String>,
#[serde(rename = "displayText")]
pub displayText: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nativeApp")]
pub nativeApp: Option<bool>,
#[serde(rename = "scopes")]
pub scopes: Option<Vec<String>>,
#[serde(rename = "userKey")]
pub userKey: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryTokens {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryToken>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUser {
#[serde(rename = "addresses")]
pub addresses: Option<Value>,
#[serde(rename = "agreedToTerms")]
pub agreedToTerms: Option<bool>,
#[serde(rename = "aliases")]
pub aliases: Option<Vec<String>>,
#[serde(rename = "archived")]
pub archived: Option<bool>,
#[serde(rename = "changePasswordAtNextLogin")]
pub changePasswordAtNextLogin: Option<bool>,
#[serde(rename = "creationTime")]
pub creationTime: Option<String>,
#[serde(rename = "customSchemas")]
pub customSchemas: Option<Value>,
#[serde(rename = "customerId")]
pub customerId: Option<String>,
#[serde(rename = "deletionTime")]
pub deletionTime: Option<String>,
#[serde(rename = "emails")]
pub emails: Option<Value>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "externalIds")]
pub externalIds: Option<Value>,
#[serde(rename = "gender")]
pub gender: Option<Value>,
#[serde(rename = "hashFunction")]
pub hashFunction: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "ims")]
pub ims: Option<Value>,
#[serde(rename = "includeInGlobalAddressList")]
pub includeInGlobalAddressList: Option<bool>,
#[serde(rename = "ipWhitelisted")]
pub ipWhitelisted: Option<bool>,
#[serde(rename = "isAdmin")]
pub isAdmin: Option<bool>,
#[serde(rename = "isDelegatedAdmin")]
pub isDelegatedAdmin: Option<bool>,
#[serde(rename = "isEnforcedIn2Sv")]
pub isEnforcedIn2Sv: Option<bool>,
#[serde(rename = "isEnrolledIn2Sv")]
pub isEnrolledIn2Sv: Option<bool>,
#[serde(rename = "isMailboxSetup")]
pub isMailboxSetup: Option<bool>,
#[serde(rename = "keywords")]
pub keywords: Option<Value>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "languages")]
pub languages: Option<Value>,
#[serde(rename = "lastLoginTime")]
pub lastLoginTime: Option<String>,
#[serde(rename = "locations")]
pub locations: Option<Value>,
#[serde(rename = "name")]
pub name: Option<DirectoryUserName>,
#[serde(rename = "nonEditableAliases")]
pub nonEditableAliases: Option<Vec<String>>,
#[serde(rename = "notes")]
pub notes: Option<Value>,
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
#[serde(rename = "organizations")]
pub organizations: Option<Value>,
#[serde(rename = "password")]
pub password: Option<String>,
#[serde(rename = "phones")]
pub phones: Option<Value>,
#[serde(rename = "posixAccounts")]
pub posixAccounts: Option<Value>,
#[serde(rename = "primaryEmail")]
pub primaryEmail: Option<String>,
#[serde(rename = "recoveryEmail")]
pub recoveryEmail: Option<String>,
#[serde(rename = "recoveryPhone")]
pub recoveryPhone: Option<String>,
#[serde(rename = "relations")]
pub relations: Option<Value>,
#[serde(rename = "sshPublicKeys")]
pub sshPublicKeys: Option<Value>,
#[serde(rename = "suspended")]
pub suspended: Option<bool>,
#[serde(rename = "suspensionReason")]
pub suspensionReason: Option<String>,
#[serde(rename = "thumbnailPhotoEtag")]
pub thumbnailPhotoEtag: Option<String>,
#[serde(rename = "thumbnailPhotoUrl")]
pub thumbnailPhotoUrl: Option<String>,
#[serde(rename = "websites")]
pub websites: Option<Value>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserAbout {
#[serde(rename = "contentType")]
pub contentType: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserAddress {
#[serde(rename = "country")]
pub country: Option<String>,
#[serde(rename = "countryCode")]
pub countryCode: Option<String>,
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "extendedAddress")]
pub extendedAddress: Option<String>,
#[serde(rename = "formatted")]
pub formatted: Option<String>,
#[serde(rename = "locality")]
pub locality: Option<String>,
#[serde(rename = "poBox")]
pub poBox: Option<String>,
#[serde(rename = "postalCode")]
pub postalCode: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "region")]
pub region: Option<String>,
#[serde(rename = "sourceIsStructured")]
pub sourceIsStructured: Option<bool>,
#[serde(rename = "streetAddress")]
pub streetAddress: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserAlias {
#[serde(rename = "alias")]
pub alias_: Option<String>,
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "primaryEmail")]
pub primaryEmail: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserEmail {
#[serde(rename = "address")]
pub address: Option<String>,
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "public_key_encryption_certificates")]
pub public_key_encryption_certificates: Option<Value>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserExternalId {
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserGender {
#[serde(rename = "addressMeAs")]
pub addressMeAs: Option<String>,
#[serde(rename = "customGender")]
pub customGender: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserIm {
#[serde(rename = "customProtocol")]
pub customProtocol: Option<String>,
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "im")]
pub im: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "protocol")]
pub protocol: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserKeyword {
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserLanguage {
#[serde(rename = "customLanguage")]
pub customLanguage: Option<String>,
#[serde(rename = "languageCode")]
pub languageCode: Option<String>,
#[serde(rename = "preference")]
pub preference: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserLocation {
#[serde(rename = "area")]
pub area: Option<String>,
#[serde(rename = "buildingId")]
pub buildingId: Option<String>,
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "deskCode")]
pub deskCode: Option<String>,
#[serde(rename = "floorName")]
pub floorName: Option<String>,
#[serde(rename = "floorSection")]
pub floorSection: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserMakeAdmin {
#[serde(rename = "status")]
pub status: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserName {
#[serde(rename = "displayName")]
pub displayName: Option<String>,
#[serde(rename = "familyName")]
pub familyName: Option<String>,
#[serde(rename = "fullName")]
pub fullName: Option<String>,
#[serde(rename = "givenName")]
pub givenName: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserOrganization {
#[serde(rename = "costCenter")]
pub costCenter: Option<String>,
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "department")]
pub department: Option<String>,
#[serde(rename = "description")]
pub description: Option<String>,
#[serde(rename = "domain")]
pub domain: Option<String>,
#[serde(rename = "fullTimeEquivalent")]
pub fullTimeEquivalent: Option<i32>,
#[serde(rename = "location")]
pub location: Option<String>,
#[serde(rename = "name")]
pub name: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "symbol")]
pub symbol: Option<String>,
#[serde(rename = "title")]
pub title: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserPhone {
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserPhoto {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "height")]
pub height: Option<i32>,
#[serde(rename = "id")]
pub id: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "mimeType")]
pub mimeType: Option<String>,
#[serde(rename = "photoData")]
pub photoData: Option<String>,
#[serde(rename = "primaryEmail")]
pub primaryEmail: Option<String>,
#[serde(rename = "width")]
pub width: Option<i32>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserPosixAccount {
#[serde(rename = "accountId")]
pub accountId: Option<String>,
#[serde(rename = "gecos")]
pub gecos: Option<String>,
#[serde(rename = "gid")]
pub gid: Option<String>,
#[serde(rename = "homeDirectory")]
pub homeDirectory: Option<String>,
#[serde(rename = "operatingSystemType")]
pub operatingSystemType: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "shell")]
pub shell: Option<String>,
#[serde(rename = "systemId")]
pub systemId: Option<String>,
#[serde(rename = "uid")]
pub uid: Option<String>,
#[serde(rename = "username")]
pub username: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserRelation {
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserSshPublicKey {
#[serde(rename = "expirationTimeUsec")]
pub expirationTimeUsec: Option<String>,
#[serde(rename = "fingerprint")]
pub fingerprint: Option<String>,
#[serde(rename = "key")]
pub key: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserUndelete {
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUserWebsite {
#[serde(rename = "customType")]
pub customType: Option<String>,
#[serde(rename = "primary")]
pub primary: Option<bool>,
#[serde(rename = "type")]
pub type_: Option<String>,
#[serde(rename = "value")]
pub value: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryUsers {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "nextPageToken")]
pub nextPageToken: Option<String>,
#[serde(rename = "trigger_event")]
pub trigger_event: Option<String>,
#[serde(rename = "users")]
pub users: Option<Vec<DirectoryUser>>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryVerificationCode {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "kind")]
pub kind: Option<String>,
#[serde(rename = "userId")]
pub userId: Option<String>,
#[serde(rename = "verificationCode")]
pub verificationCode: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DirectoryVerificationCodes {
#[serde(rename = "etag")]
pub etag: Option<String>,
#[serde(rename = "items")]
pub items: Option<Vec<DirectoryVerificationCode>>,
#[serde(rename = "kind")]
pub kind: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryChromeosdevicesGetQueryParams {
#[serde(rename = "projection")]
pub projection: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryChromeosdevicesListQueryParams {
#[serde(rename = "includeChildOrgunits")]
pub includeChildOrgunits: Option<bool>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "orderBy")]
pub orderBy: Option<String>,
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "projection")]
pub projection: Option<String>,
#[serde(rename = "query")]
pub query: Option<String>,
#[serde(rename = "sortOrder")]
pub sortOrder: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryChromeosdevicesMoveDevicesToOuQueryParams {
#[serde(rename = "orgUnitPath")]
orgUnitPath: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryChromeosdevicesPatchQueryParams {
#[serde(rename = "projection")]
pub projection: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryChromeosdevicesUpdateQueryParams {
#[serde(rename = "projection")]
pub projection: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryDomainAliasesListQueryParams {
#[serde(rename = "parentDomainName")]
pub parentDomainName: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryGroupsListQueryParams {
#[serde(rename = "customer")]
pub customer: Option<String>,
#[serde(rename = "domain")]
pub domain: Option<String>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "orderBy")]
pub orderBy: Option<String>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "query")]
pub query: Option<String>,
#[serde(rename = "sortOrder")]
pub sortOrder: Option<String>,
#[serde(rename = "userKey")]
pub userKey: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryMembersListQueryParams {
#[serde(rename = "includeDerivedMembership")]
pub includeDerivedMembership: Option<bool>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "roles")]
pub roles: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryMobiledevicesGetQueryParams {
#[serde(rename = "projection")]
pub projection: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryMobiledevicesListQueryParams {
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "orderBy")]
pub orderBy: Option<String>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "projection")]
pub projection: Option<String>,
#[serde(rename = "query")]
pub query: Option<String>,
#[serde(rename = "sortOrder")]
pub sortOrder: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryOrgunitsListQueryParams {
#[serde(rename = "orgUnitPath")]
pub orgUnitPath: Option<String>,
#[serde(rename = "type")]
pub type_: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryRoleAssignmentsListQueryParams {
#[serde(rename = "includeIndirectRoleAssignments")]
pub includeIndirectRoleAssignments: Option<bool>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "roleId")]
pub roleId: Option<String>,
#[serde(rename = "userKey")]
pub userKey: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryRolesListQueryParams {
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryUsersGetQueryParams {
#[serde(rename = "customFieldMask")]
pub customFieldMask: Option<String>,
#[serde(rename = "projection")]
pub projection: Option<String>,
#[serde(rename = "viewType")]
pub viewType: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryUsersInsertQueryParams {
#[serde(rename = "resolveConflictAccount")]
pub resolveConflictAccount: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryUsersListQueryParams {
#[serde(rename = "customFieldMask")]
pub customFieldMask: Option<String>,
#[serde(rename = "customer")]
pub customer: Option<String>,
#[serde(rename = "domain")]
pub domain: Option<String>,
#[serde(rename = "event")]
pub event: Option<String>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "orderBy")]
pub orderBy: Option<String>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "projection")]
pub projection: Option<String>,
#[serde(rename = "query")]
pub query: Option<String>,
#[serde(rename = "showDeleted")]
pub showDeleted: Option<String>,
#[serde(rename = "sortOrder")]
pub sortOrder: Option<String>,
#[serde(rename = "viewType")]
pub viewType: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DirectoryUsersWatchQueryParams {
#[serde(rename = "customFieldMask")]
pub customFieldMask: Option<String>,
#[serde(rename = "customer")]
pub customer: Option<String>,
#[serde(rename = "domain")]
pub domain: Option<String>,
#[serde(rename = "event")]
pub event: Option<String>,
#[serde(rename = "maxResults")]
pub maxResults: Option<i32>,
#[serde(rename = "orderBy")]
pub orderBy: Option<String>,
#[serde(rename = "pageToken")]
pub pageToken: Option<String>,
#[serde(rename = "projection")]
pub projection: Option<String>,
#[serde(rename = "query")]
pub query: Option<String>,
#[serde(rename = "showDeleted")]
pub showDeleted: Option<String>,
#[serde(rename = "sortOrder")]
pub sortOrder: Option<String>,
#[serde(rename = "viewType")]
pub viewType: Option<String>,
}
#[async_trait::async_trait]
pub trait GoogleWorkspaceCredentials {
async fn get_access_token(&self) -> anyhow::Result<String>;
}
pub struct GoogleWorkspaceAPI<T: GoogleWorkspaceCredentials> {
pub credentials: T,
}
impl<T: GoogleWorkspaceCredentials> GoogleWorkspaceAPI<T> {
pub fn new(credentials: T) -> Self {
Self { credentials }
}
pub fn base_url(&self) -> &'static str {
"https://admin.googleapis.com"
}
pub async fn client(&self) -> anyhow::Result<Client> {
let mut headers = header::HeaderMap::new();
let access_token = self.credentials.get_access_token().await?;
let header_value = header::HeaderValue::from_str(&format!("Bearer {}", access_token))?;
headers.insert(header::AUTHORIZATION, header_value);
let client = Client::builder().default_headers(headers).build()?;
Ok(client)
}
pub async fn asps_delete(&self, codeId: i32, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/asps/{codeId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn asps_get(&self, codeId: i32, userKey: String) -> anyhow::Result<DirectoryAsp> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/asps/{codeId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryAsp = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn asps_list(&self, userKey: String) -> anyhow::Result<DirectoryAsps> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/asps",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryAsps = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn channels_stop(&self, req: DirectoryChannel) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory_v1/channels/stop",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_action(
&self,
customerId: String,
resourceId: String,
req: DirectoryChromeOsDeviceAction,
) -> anyhow::Result<Value> {
let url = format!
("{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos/{resourceId}/action",
base_url = self.base_url());
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_get(
&self,
customerId: String,
deviceId: String,
query_params: DirectoryChromeosdevicesGetQueryParams,
) -> anyhow::Result<DirectoryChromeOsDevice> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos/{deviceId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryChromeOsDevice = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_list(
&self,
customerId: String,
query_params: DirectoryChromeosdevicesListQueryParams,
) -> anyhow::Result<DirectoryChromeOsDevices> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryChromeOsDevices = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_moveDevicesToOu(
&self,
customerId: String,
req: DirectoryChromeOsMoveDevicesToOu,
query_params: DirectoryChromeosdevicesMoveDevicesToOuQueryParams,
) -> anyhow::Result<Value> {
let url =
format!
("{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos/moveDevicesToOu",
base_url = self.base_url());
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.query(&query_params);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_patch(
&self,
customerId: String,
deviceId: String,
req: DirectoryChromeOsDevice,
query_params: DirectoryChromeosdevicesPatchQueryParams,
) -> anyhow::Result<DirectoryChromeOsDevice> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos/{deviceId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.query(&query_params);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryChromeOsDevice = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn chromeosdevices_update(
&self,
customerId: String,
deviceId: String,
req: DirectoryChromeOsDevice,
query_params: DirectoryChromeosdevicesUpdateQueryParams,
) -> anyhow::Result<DirectoryChromeOsDevice> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/chromeos/{deviceId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.query(&query_params);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryChromeOsDevice = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn customers_get(&self, customerKey: String) -> anyhow::Result<DirectoryCustomer> {
let url = format!(
"{base_url}/admin/directory/v1/customers/{customerKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryCustomer = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn customers_patch(
&self,
customerKey: String,
req: DirectoryCustomer,
) -> anyhow::Result<DirectoryCustomer> {
let url = format!(
"{base_url}/admin/directory/v1/customers/{customerKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryCustomer = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn customers_update(
&self,
customerKey: String,
req: DirectoryCustomer,
) -> anyhow::Result<DirectoryCustomer> {
let url = format!(
"{base_url}/admin/directory/v1/customers/{customerKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryCustomer = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domainAliases_delete(
&self,
customer: String,
domainAliasName: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domainaliases/{domainAliasName}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domainAliases_get(
&self,
customer: String,
domainAliasName: String,
) -> anyhow::Result<DirectoryDomainAlias> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domainaliases/{domainAliasName}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomainAlias = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domainAliases_insert(
&self,
customer: String,
req: DirectoryDomainAlias,
) -> anyhow::Result<DirectoryDomainAlias> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domainaliases",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomainAlias = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domainAliases_list(
&self,
customer: String,
query_params: DirectoryDomainAliasesListQueryParams,
) -> anyhow::Result<DirectoryDomainAliases> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domainaliases",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomainAliases = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domains_delete(
&self,
customer: String,
domainName: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domains/{domainName}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domains_get(
&self,
customer: String,
domainName: String,
) -> anyhow::Result<DirectoryDomains> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domains/{domainName}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomains = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domains_insert(
&self,
customer: String,
req: DirectoryDomains,
) -> anyhow::Result<DirectoryDomains> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domains",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomains = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn domains_list(&self, customer: String) -> anyhow::Result<DirectoryDomains2> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/domains",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryDomains2 = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_delete(&self, groupKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_get(&self, groupKey: String) -> anyhow::Result<DirectoryGroup> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryGroup = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_insert(&self, req: DirectoryGroup) -> anyhow::Result<DirectoryGroup> {
let url = format!(
"{base_url}/admin/directory/v1/groups",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryGroup = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_list(
&self,
query_params: DirectoryGroupsListQueryParams,
) -> anyhow::Result<DirectoryGroups> {
let url = format!(
"{base_url}/admin/directory/v1/groups",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryGroups = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_patch(
&self,
groupKey: String,
req: DirectoryGroup,
) -> anyhow::Result<DirectoryGroup> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryGroup = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn groups_update(
&self,
groupKey: String,
req: DirectoryGroup,
) -> anyhow::Result<DirectoryGroup> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryGroup = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_delete(
&self,
groupKey: String,
memberKey: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members/{memberKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_get(
&self,
groupKey: String,
memberKey: String,
) -> anyhow::Result<DirectoryMember> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members/{memberKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMember = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_hasMember(
&self,
groupKey: String,
memberKey: String,
) -> anyhow::Result<DirectoryMembersHasMember> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/hasMember/{memberKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMembersHasMember = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_insert(
&self,
groupKey: String,
req: DirectoryMember,
) -> anyhow::Result<DirectoryMember> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMember = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_list(
&self,
groupKey: String,
query_params: DirectoryMembersListQueryParams,
) -> anyhow::Result<DirectoryMembers> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMembers = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_patch(
&self,
groupKey: String,
memberKey: String,
req: DirectoryMember,
) -> anyhow::Result<DirectoryMember> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members/{memberKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMember = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn members_update(
&self,
groupKey: String,
memberKey: String,
req: DirectoryMember,
) -> anyhow::Result<DirectoryMember> {
let url = format!(
"{base_url}/admin/directory/v1/groups/{groupKey}/members/{memberKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMember = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn mobiledevices_action(
&self,
customerId: String,
resourceId: String,
req: DirectoryMobileDeviceAction,
) -> anyhow::Result<Value> {
let url = format!
("{base_url}/admin/directory/v1/customer/{customerId}/devices/mobile/{resourceId}/action",
base_url = self.base_url());
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn mobiledevices_delete(
&self,
customerId: String,
resourceId: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/mobile/{resourceId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn mobiledevices_get(
&self,
customerId: String,
resourceId: String,
query_params: DirectoryMobiledevicesGetQueryParams,
) -> anyhow::Result<DirectoryMobileDevice> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/mobile/{resourceId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMobileDevice = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn mobiledevices_list(
&self,
customerId: String,
query_params: DirectoryMobiledevicesListQueryParams,
) -> anyhow::Result<DirectoryMobileDevices> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/devices/mobile",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryMobileDevices = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_delete(
&self,
customerId: String,
orgUnitPath: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits/{orgUnitPath}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_get(
&self,
customerId: String,
orgUnitPath: String,
) -> anyhow::Result<DirectoryOrgUnit> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits/{orgUnitPath}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryOrgUnit = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_insert(
&self,
customerId: String,
req: DirectoryOrgUnit,
) -> anyhow::Result<DirectoryOrgUnit> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryOrgUnit = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_list(
&self,
customerId: String,
query_params: DirectoryOrgunitsListQueryParams,
) -> anyhow::Result<DirectoryOrgUnits> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryOrgUnits = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_patch(
&self,
customerId: String,
orgUnitPath: String,
req: DirectoryOrgUnit,
) -> anyhow::Result<DirectoryOrgUnit> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits/{orgUnitPath}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryOrgUnit = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn orgunits_update(
&self,
customerId: String,
orgUnitPath: String,
req: DirectoryOrgUnit,
) -> anyhow::Result<DirectoryOrgUnit> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/orgunits/{orgUnitPath}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryOrgUnit = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn privileges_list(&self, customer: String) -> anyhow::Result<DirectoryPrivileges> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles/ALL/privileges",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryPrivileges = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roleAssignments_delete(
&self,
customer: String,
roleAssignmentId: String,
) -> anyhow::Result<Value> {
let url =
format!
("{base_url}/admin/directory/v1/customer/{customer}/roleassignments/{roleAssignmentId}",
base_url = self.base_url());
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roleAssignments_get(
&self,
customer: String,
roleAssignmentId: String,
) -> anyhow::Result<DirectoryRoleAssignment> {
let url =
format!
("{base_url}/admin/directory/v1/customer/{customer}/roleassignments/{roleAssignmentId}",
base_url = self.base_url());
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRoleAssignment = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roleAssignments_insert(
&self,
customer: String,
req: DirectoryRoleAssignment,
) -> anyhow::Result<DirectoryRoleAssignment> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roleassignments",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRoleAssignment = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roleAssignments_list(
&self,
customer: String,
query_params: DirectoryRoleAssignmentsListQueryParams,
) -> anyhow::Result<DirectoryRoleAssignments> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roleassignments",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRoleAssignments = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_delete(&self, customer: String, roleId: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles/{roleId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_get(
&self,
customer: String,
roleId: String,
) -> anyhow::Result<DirectoryRole> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles/{roleId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRole = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_insert(
&self,
customer: String,
req: DirectoryRole,
) -> anyhow::Result<DirectoryRole> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRole = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_list(
&self,
customer: String,
query_params: DirectoryRolesListQueryParams,
) -> anyhow::Result<DirectoryRoles> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRoles = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_patch(
&self,
customer: String,
roleId: String,
req: DirectoryRole,
) -> anyhow::Result<DirectoryRole> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles/{roleId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRole = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn roles_update(
&self,
customer: String,
roleId: String,
req: DirectoryRole,
) -> anyhow::Result<DirectoryRole> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customer}/roles/{roleId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryRole = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_delete(
&self,
customerId: String,
schemaKey: String,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas/{schemaKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_get(
&self,
customerId: String,
schemaKey: String,
) -> anyhow::Result<DirectorySchema> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas/{schemaKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectorySchema = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_insert(
&self,
customerId: String,
req: DirectorySchema,
) -> anyhow::Result<DirectorySchema> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectorySchema = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_list(&self, customerId: String) -> anyhow::Result<DirectorySchemas> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectorySchemas = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_patch(
&self,
customerId: String,
schemaKey: String,
req: DirectorySchema,
) -> anyhow::Result<DirectorySchema> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas/{schemaKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectorySchema = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn schemas_update(
&self,
customerId: String,
schemaKey: String,
req: DirectorySchema,
) -> anyhow::Result<DirectorySchema> {
let url = format!(
"{base_url}/admin/directory/v1/customer/{customerId}/schemas/{schemaKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectorySchema = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn tokens_delete(&self, clientId: String, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/tokens/{clientId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn tokens_get(
&self,
clientId: String,
userKey: String,
) -> anyhow::Result<DirectoryToken> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/tokens/{clientId}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryToken = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn tokens_list(&self, userKey: String) -> anyhow::Result<DirectoryTokens> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/tokens",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryTokens = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn twoStepVerification_turnOff(&self, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/twoStepVerification/turnOff",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_delete(&self, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::DELETE, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_get(
&self,
userKey: String,
query_params: DirectoryUsersGetQueryParams,
) -> anyhow::Result<DirectoryUser> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryUser = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_insert(
&self,
req: DirectoryUser,
query_params: DirectoryUsersInsertQueryParams,
) -> anyhow::Result<DirectoryUser> {
let url = format!(
"{base_url}/admin/directory/v1/users",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.query(&query_params);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryUser = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_list(
&self,
query_params: DirectoryUsersListQueryParams,
) -> anyhow::Result<DirectoryUsers> {
let url = format!(
"{base_url}/admin/directory/v1/users",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let request_builder = request_builder.query(&query_params);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryUsers = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_makeAdmin(
&self,
userKey: String,
req: DirectoryUserMakeAdmin,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/makeAdmin",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_patch(
&self,
userKey: String,
req: DirectoryUser,
) -> anyhow::Result<DirectoryUser> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PATCH, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryUser = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_signOut(&self, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/signOut",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_undelete(
&self,
userKey: String,
req: DirectoryUserUndelete,
) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/undelete",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_update(
&self,
userKey: String,
req: DirectoryUser,
) -> anyhow::Result<DirectoryUser> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::PUT, url);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryUser = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn users_watch(
&self,
req: DirectoryChannel,
query_params: DirectoryUsersWatchQueryParams,
) -> anyhow::Result<DirectoryChannel> {
let url = format!(
"{base_url}/admin/directory/v1/users/watch",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let request_builder = request_builder.query(&query_params);
let request_builder = request_builder.json(&req);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryChannel = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn verificationCodes_generate(&self, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/verificationCodes/generate",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn verificationCodes_invalidate(&self, userKey: String) -> anyhow::Result<Value> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/verificationCodes/invalidate",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::POST, url);
let response = request_builder.send().await?.error_for_status()?;
let output: Value = serde_json::from_value(response.json().await?)?;
Ok(output)
}
pub async fn verificationCodes_list(
&self,
userKey: String,
) -> anyhow::Result<DirectoryVerificationCodes> {
let url = format!(
"{base_url}/admin/directory/v1/users/{userKey}/verificationCodes",
base_url = self.base_url()
);
let client = self.client().await?;
let request_builder = client.request(reqwest::Method::GET, url);
let response = request_builder.send().await?.error_for_status()?;
let output: DirectoryVerificationCodes = serde_json::from_value(response.json().await?)?;
Ok(output)
}
}