@software-hardware-integration-lab/sdk-shield 3.0.0 → 3.5.2-beta.1e7cfc5

package/bin/sdk/models/managedObject/index.js

@@ -0,0 +1,140 @@
+import { SecurityClassListObject } from '../index.js';
+export function createAvdIntermediaryFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAvdIntermediary;
+}
+export function createDeviceFromDiscriminatorValue(parseNode) {
+    return deserializeIntoDevice;
+}
+export function createIntermediaryFromDiscriminatorValue(parseNode) {
+    return deserializeIntoIntermediary;
+}
+export function createPrivilegedDeviceFromDiscriminatorValue(parseNode) {
+    return deserializeIntoPrivilegedDevice;
+}
+export function createPrivilegedUserFromDiscriminatorValue(parseNode) {
+    return deserializeIntoPrivilegedUser;
+}
+export function createUserFromDiscriminatorValue(parseNode) {
+    return deserializeIntoUser;
+}
+export function deserializeIntoAvdIntermediary(avdIntermediary = {}) {
+    return {
+        "addressRangeCIDR": n => { avdIntermediary.addressRangeCIDR = n.getStringValue(); },
+        "assignmentGroup": n => { avdIntermediary.assignmentGroup = n.getGuidValue(); },
+        "index": n => { avdIntermediary.index = n.getNumberValue(); },
+        "location": n => { avdIntermediary.location = n.getStringValue(); },
+        "resourceId": n => { avdIntermediary.resourceId = n.getStringValue(); },
+        "sessionHostGroup": n => { avdIntermediary.sessionHostGroup = n.getGuidValue(); },
+        "sessionHostPrefix": n => { avdIntermediary.sessionHostPrefix = n.getStringValue(); },
+        "vmSku": n => { avdIntermediary.vmSku = n.getStringValue(); },
+    };
+}
+export function deserializeIntoDevice(device = {}) {
+    return {
+        "commissionedDate": n => { device.commissionedDate = n.getDateValue(); },
+        "displayName": n => { device.displayName = n.getStringValue(); },
+        "id": n => { device.id = n.getGuidValue(); },
+        "parentDeviceId": n => { device.parentDeviceId = n.getStringValue(); },
+        "securityClass": n => { device.securityClass = n.getEnumValue(SecurityClassListObject); },
+        "uniqueGroupId": n => { device.uniqueGroupId = n.getStringValue(); },
+    };
+}
+export function deserializeIntoIntermediary(intermediary = {}) {
+    return {
+        "id": n => { intermediary.id = n.getGuidValue(); },
+        "kind": n => { intermediary.kind = n.getStringValue(); },
+        "name": n => { intermediary.name = n.getStringValue(); },
+        "securityClass": n => { intermediary.securityClass = n.getEnumValue(SecurityClassListObject); },
+    };
+}
+export function deserializeIntoPrivilegedDevice(privilegedDevice = {}) {
+    return {
+        ...deserializeIntoDevice(privilegedDevice),
+        "groupAssignmentId": n => { privilegedDevice.groupAssignmentId = n.getStringValue(); },
+        "userAssignmentId": n => { privilegedDevice.userAssignmentId = n.getStringValue(); },
+        "userAssignmentList": n => { privilegedDevice.userAssignmentList = n.getCollectionOfPrimitiveValues("string"); },
+    };
+}
+export function deserializeIntoPrivilegedUser(privilegedUser = {}) {
+    return {
+        ...deserializeIntoUser(privilegedUser),
+        "deviceAssignmentList": n => { privilegedUser.deviceAssignmentList = n.getCollectionOfPrimitiveValues("string"); },
+        "generatedPassword": n => { privilegedUser.generatedPassword = n.getStringValue(); },
+        "parentId": n => { privilegedUser.parentId = n.getGuidValue(); },
+        "temporaryAccessPass": n => { privilegedUser.temporaryAccessPass = n.getStringValue(); },
+    };
+}
+export function deserializeIntoUser(user = {}) {
+    return {
+        "creationDate": n => { user.creationDate = n.getDateValue(); },
+        "displayName": n => { user.displayName = n.getStringValue(); },
+        "firstName": n => { user.firstName = n.getStringValue(); },
+        "id": n => { user.id = n.getGuidValue(); },
+        "intermediaryAssignmentList": n => { user.intermediaryAssignmentList = n.getCollectionOfPrimitiveValues("string"); },
+        "lastName": n => { user.lastName = n.getStringValue(); },
+        "securityClass": n => { user.securityClass = n.getEnumValue(SecurityClassListObject); },
+        "siloAssignmentList": n => { user.siloAssignmentList = n.getCollectionOfPrimitiveValues("string"); },
+        "uiEducation": n => { user.uiEducation = n.getBooleanValue(); },
+        "uniqueGroupId": n => { user.uniqueGroupId = n.getGuidValue(); },
+        "upn": n => { user.upn = n.getStringValue(); },
+    };
+}
+export function serializeAvdIntermediary(writer, avdIntermediary = {}, isSerializingDerivedType = false) {
+    if (!avdIntermediary || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeStringValue("addressRangeCIDR", avdIntermediary.addressRangeCIDR);
+    writer.writeNumberValue("index", avdIntermediary.index);
+    writer.writeStringValue("location", avdIntermediary.location);
+    writer.writeStringValue("sessionHostPrefix", avdIntermediary.sessionHostPrefix);
+    writer.writeStringValue("vmSku", avdIntermediary.vmSku);
+    writer.writeAdditionalData(avdIntermediary.additionalData);
+}
+export function serializeDevice(writer, device = {}, isSerializingDerivedType = false) {
+    if (!device || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeDateValue("commissionedDate", device.commissionedDate);
+    writer.writeStringValue("displayName", device.displayName);
+    writer.writeStringValue("parentDeviceId", device.parentDeviceId);
+    writer.writeEnumValue("securityClass", device.securityClass);
+    writer.writeAdditionalData(device.additionalData);
+}
+export function serializeIntermediary(writer, intermediary = {}, isSerializingDerivedType = false) {
+    if (!intermediary || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeStringValue("kind", intermediary.kind);
+    writer.writeStringValue("name", intermediary.name);
+    writer.writeEnumValue("securityClass", intermediary.securityClass);
+    writer.writeAdditionalData(intermediary.additionalData);
+}
+export function serializePrivilegedDevice(writer, privilegedDevice = {}, isSerializingDerivedType = false) {
+    if (!privilegedDevice || isSerializingDerivedType) {
+        return;
+    }
+    serializeDevice(writer, privilegedDevice, isSerializingDerivedType);
+    writer.writeStringValue("groupAssignmentId", privilegedDevice.groupAssignmentId);
+    writer.writeCollectionOfPrimitiveValues("userAssignmentList", privilegedDevice.userAssignmentList);
+}
+export function serializePrivilegedUser(writer, privilegedUser = {}, isSerializingDerivedType = false) {
+    if (!privilegedUser || isSerializingDerivedType) {
+        return;
+    }
+    serializeUser(writer, privilegedUser, isSerializingDerivedType);
+    writer.writeCollectionOfPrimitiveValues("deviceAssignmentList", privilegedUser.deviceAssignmentList);
+}
+export function serializeUser(writer, user = {}, isSerializingDerivedType = false) {
+    if (!user || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeStringValue("displayName", user.displayName);
+    writer.writeStringValue("firstName", user.firstName);
+    writer.writeCollectionOfPrimitiveValues("intermediaryAssignmentList", user.intermediaryAssignmentList);
+    writer.writeStringValue("lastName", user.lastName);
+    writer.writeEnumValue("securityClass", user.securityClass);
+    writer.writeCollectionOfPrimitiveValues("siloAssignmentList", user.siloAssignmentList);
+    writer.writeBooleanValue("uiEducation", user.uiEducation);
+    writer.writeStringValue("upn", user.upn);
+    writer.writeAdditionalData(user.additionalData);
+}

package/bin/sdk/models/objectPage/index.d.ts

@@ -0,0 +1,174 @@
+import { type Device, type PrivilegedDevice, type PrivilegedUser, type User } from '../managedObject/index.js';
+import { type AdditionalDataHolder, type Parsable, type ParseNode, type SerializationWriter } from '@microsoft/kiota-abstractions';
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {Device | PrivilegedDevice}
+ */
+export declare function createManagedDevice_valueFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {ManagedDevice}
+ */
+export declare function createManagedDeviceFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {ManagedPrivilegedDevice}
+ */
+export declare function createManagedPrivilegedDeviceFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {ManagedPrivilegedUser}
+ */
+export declare function createManagedPrivilegedUserFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {PrivilegedUser | User}
+ */
+export declare function createManagedUser_valueFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {ManagedUser}
+ */
+export declare function createManagedUserFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * The deserialization information for the current model
+ * @param ManagedDevice The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedDevice(managedDevice?: Partial<ManagedDevice> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param ManagedDevice_value The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedDevice_value(managedDevice_value?: Partial<Device | PrivilegedDevice> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param ManagedPrivilegedDevice The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedPrivilegedDevice(managedPrivilegedDevice?: Partial<ManagedPrivilegedDevice> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param ManagedPrivilegedUser The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedPrivilegedUser(managedPrivilegedUser?: Partial<ManagedPrivilegedUser> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param ManagedUser The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedUser(managedUser?: Partial<ManagedUser> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param ManagedUser_value The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoManagedUser_value(managedUser_value?: Partial<PrivilegedUser | User> | undefined): Record<string, (node: ParseNode) => void>;
+export interface ManagedDevice extends AdditionalDataHolder, Parsable {
+    /**
+     * The OdataCount property
+     */
+    odataCount?: number | null;
+    /**
+     * The OdataNextLink property
+     */
+    odataNextLink?: string | null;
+    /**
+     * The value property
+     */
+    value?: (Device | PrivilegedDevice)[] | null;
+}
+export type ManagedDevice_value = Device | PrivilegedDevice;
+export interface ManagedPrivilegedDevice extends AdditionalDataHolder, Parsable {
+    /**
+     * The OdataCount property
+     */
+    odataCount?: number | null;
+    /**
+     * The OdataNextLink property
+     */
+    odataNextLink?: string | null;
+    /**
+     * The value property
+     */
+    value?: PrivilegedDevice[] | null;
+}
+export interface ManagedPrivilegedUser extends AdditionalDataHolder, Parsable {
+    /**
+     * The OdataCount property
+     */
+    odataCount?: number | null;
+    /**
+     * The OdataNextLink property
+     */
+    odataNextLink?: string | null;
+    /**
+     * The value property
+     */
+    value?: PrivilegedUser[] | null;
+}
+export interface ManagedUser extends AdditionalDataHolder, Parsable {
+    /**
+     * The OdataCount property
+     */
+    odataCount?: number | null;
+    /**
+     * The OdataNextLink property
+     */
+    odataNextLink?: string | null;
+    /**
+     * The value property
+     */
+    value?: (PrivilegedUser | User)[] | null;
+}
+export type ManagedUser_value = PrivilegedUser | User;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedDevice The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedDevice(writer: SerializationWriter, managedDevice?: Partial<ManagedDevice> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedDevice_value The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedDevice_value(writer: SerializationWriter, managedDevice_value?: Partial<Device | PrivilegedDevice> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedPrivilegedDevice The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedPrivilegedDevice(writer: SerializationWriter, managedPrivilegedDevice?: Partial<ManagedPrivilegedDevice> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedPrivilegedUser The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedPrivilegedUser(writer: SerializationWriter, managedPrivilegedUser?: Partial<ManagedPrivilegedUser> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedUser The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedUser(writer: SerializationWriter, managedUser?: Partial<ManagedUser> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param ManagedUser_value The instance to serialize from.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeManagedUser_value(writer: SerializationWriter, managedUser_value?: Partial<PrivilegedUser | User> | undefined | null, isSerializingDerivedType?: boolean): void;

package/bin/sdk/models/objectPage/index.js

@@ -0,0 +1,103 @@
+import { createDeviceFromDiscriminatorValue, createPrivilegedDeviceFromDiscriminatorValue, createPrivilegedUserFromDiscriminatorValue, createUserFromDiscriminatorValue, deserializeIntoDevice, deserializeIntoPrivilegedDevice, deserializeIntoPrivilegedUser, deserializeIntoUser, serializeDevice, serializePrivilegedDevice, serializePrivilegedUser, serializeUser } from '../managedObject/index.js';
+export function createManagedDevice_valueFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedDevice_value;
+}
+export function createManagedDeviceFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedDevice;
+}
+export function createManagedPrivilegedDeviceFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedPrivilegedDevice;
+}
+export function createManagedPrivilegedUserFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedPrivilegedUser;
+}
+export function createManagedUser_valueFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedUser_value;
+}
+export function createManagedUserFromDiscriminatorValue(parseNode) {
+    return deserializeIntoManagedUser;
+}
+export function deserializeIntoManagedDevice(managedDevice = {}) {
+    return {
+        "@odata.count": n => { managedDevice.odataCount = n.getNumberValue(); },
+        "@odata.nextLink": n => { managedDevice.odataNextLink = n.getStringValue(); },
+        "value": n => { managedDevice.value = n.getCollectionOfObjectValues(createPrivilegedDeviceFromDiscriminatorValue) ?? n.getCollectionOfObjectValues(createDeviceFromDiscriminatorValue); },
+    };
+}
+export function deserializeIntoManagedDevice_value(managedDevice_value = {}) {
+    return {
+        ...deserializeIntoDevice(managedDevice_value),
+        ...deserializeIntoPrivilegedDevice(managedDevice_value),
+    };
+}
+export function deserializeIntoManagedPrivilegedDevice(managedPrivilegedDevice = {}) {
+    return {
+        "@odata.count": n => { managedPrivilegedDevice.odataCount = n.getNumberValue(); },
+        "@odata.nextLink": n => { managedPrivilegedDevice.odataNextLink = n.getStringValue(); },
+        "value": n => { managedPrivilegedDevice.value = n.getCollectionOfObjectValues(createPrivilegedDeviceFromDiscriminatorValue); },
+    };
+}
+export function deserializeIntoManagedPrivilegedUser(managedPrivilegedUser = {}) {
+    return {
+        "@odata.count": n => { managedPrivilegedUser.odataCount = n.getNumberValue(); },
+        "@odata.nextLink": n => { managedPrivilegedUser.odataNextLink = n.getStringValue(); },
+        "value": n => { managedPrivilegedUser.value = n.getCollectionOfObjectValues(createPrivilegedUserFromDiscriminatorValue); },
+    };
+}
+export function deserializeIntoManagedUser(managedUser = {}) {
+    return {
+        "@odata.count": n => { managedUser.odataCount = n.getNumberValue(); },
+        "@odata.nextLink": n => { managedUser.odataNextLink = n.getStringValue(); },
+        "value": n => { managedUser.value = n.getCollectionOfObjectValues(createPrivilegedUserFromDiscriminatorValue) ?? n.getCollectionOfObjectValues(createUserFromDiscriminatorValue); },
+    };
+}
+export function deserializeIntoManagedUser_value(managedUser_value = {}) {
+    return {
+        ...deserializeIntoPrivilegedUser(managedUser_value),
+        ...deserializeIntoUser(managedUser_value),
+    };
+}
+export function serializeManagedDevice(writer, managedDevice = {}, isSerializingDerivedType = false) {
+    if (!managedDevice || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("@odata.count", managedDevice.odataCount);
+    writer.writeStringValue("@odata.nextLink", managedDevice.odataNextLink);
+    writer.writeCollectionOfObjectValues("value", managedDevice.value, serializeManagedDevice_value);
+    writer.writeAdditionalData(managedDevice.additionalData);
+}
+export function serializeManagedDevice_value(writer, managedDevice_value = {}, isSerializingDerivedType = false) {
+    serializeDevice(writer, managedDevice_value);
+    serializePrivilegedDevice(writer, managedDevice_value);
+}
+export function serializeManagedPrivilegedDevice(writer, managedPrivilegedDevice = {}, isSerializingDerivedType = false) {
+    if (!managedPrivilegedDevice || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("@odata.count", managedPrivilegedDevice.odataCount);
+    writer.writeStringValue("@odata.nextLink", managedPrivilegedDevice.odataNextLink);
+    writer.writeCollectionOfObjectValues("value", managedPrivilegedDevice.value, serializePrivilegedDevice);
+    writer.writeAdditionalData(managedPrivilegedDevice.additionalData);
+}
+export function serializeManagedPrivilegedUser(writer, managedPrivilegedUser = {}, isSerializingDerivedType = false) {
+    if (!managedPrivilegedUser || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("@odata.count", managedPrivilegedUser.odataCount);
+    writer.writeStringValue("@odata.nextLink", managedPrivilegedUser.odataNextLink);
+    writer.writeCollectionOfObjectValues("value", managedPrivilegedUser.value, serializePrivilegedUser);
+    writer.writeAdditionalData(managedPrivilegedUser.additionalData);
+}
+export function serializeManagedUser(writer, managedUser = {}, isSerializingDerivedType = false) {
+    if (!managedUser || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("@odata.count", managedUser.odataCount);
+    writer.writeStringValue("@odata.nextLink", managedUser.odataNextLink);
+    writer.writeCollectionOfObjectValues("value", managedUser.value, serializeManagedUser_value);
+    writer.writeAdditionalData(managedUser.additionalData);
+}
+export function serializeManagedUser_value(writer, managedUser_value = {}, isSerializingDerivedType = false) {
+    serializePrivilegedUser(writer, managedUser_value);
+    serializeUser(writer, managedUser_value);
+}

package/bin/sdk/models/objectPage/intermediary/index.d.ts

@@ -0,0 +1,60 @@
+import { type AvdIntermediary, type Intermediary } from '../../managedObject/index.js';
+import { type AdditionalDataHolder, type Parsable, type ParseNode, type SerializationWriter } from '@microsoft/kiota-abstractions';
+export interface Avd extends AdditionalDataHolder, Parsable {
+    /**
+     * The OdataCount property
+     */
+    odataCount?: number | null;
+    /**
+     * The OdataNextLink property
+     */
+    odataNextLink?: string | null;
+    /**
+     * The value property
+     */
+    value?: Avd_value[] | null;
+}
+export interface Avd_value extends Intermediary, Parsable {
+    /**
+     * The properties property
+     */
+    properties?: AvdIntermediary | null;
+}
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {Avd_value}
+ */
+export declare function createAvd_valueFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * Creates a new instance of the appropriate class based on discriminator value
+ * @param parseNode The parse node to use to read the discriminator value and create the object
+ * @returns {Avd}
+ */
+export declare function createAvdFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+/**
+ * The deserialization information for the current model
+ * @param Avd The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoAvd(avd?: Partial<Avd> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * The deserialization information for the current model
+ * @param Avd_value The instance to deserialize into.
+ * @returns {Record<string, (node: ParseNode) => void>}
+ */
+export declare function deserializeIntoAvd_value(avd_value?: Partial<Avd_value> | undefined): Record<string, (node: ParseNode) => void>;
+/**
+ * Serializes information the current object
+ * @param Avd The instance to serialize from.
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeAvd(writer: SerializationWriter, avd?: Partial<Avd> | undefined | null, isSerializingDerivedType?: boolean): void;
+/**
+ * Serializes information the current object
+ * @param Avd_value The instance to serialize from.
+ * @param isSerializingDerivedType A boolean indicating whether the serialization is for a derived type.
+ * @param writer Serialization writer to use to serialize this model
+ */
+export declare function serializeAvd_value(writer: SerializationWriter, avd_value?: Partial<Avd_value> | undefined | null, isSerializingDerivedType?: boolean): void;

package/bin/sdk/models/objectPage/intermediary/index.js

@@ -0,0 +1,36 @@
+import { createAvdIntermediaryFromDiscriminatorValue, deserializeIntoIntermediary, serializeAvdIntermediary, serializeIntermediary } from '../../managedObject/index.js';
+export function createAvd_valueFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAvd_value;
+}
+export function createAvdFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAvd;
+}
+export function deserializeIntoAvd(avd = {}) {
+    return {
+        "@odata.count": n => { avd.odataCount = n.getNumberValue(); },
+        "@odata.nextLink": n => { avd.odataNextLink = n.getStringValue(); },
+        "value": n => { avd.value = n.getCollectionOfObjectValues(createAvd_valueFromDiscriminatorValue); },
+    };
+}
+export function deserializeIntoAvd_value(avd_value = {}) {
+    return {
+        ...deserializeIntoIntermediary(avd_value),
+        "properties": n => { avd_value.properties = n.getObjectValue(createAvdIntermediaryFromDiscriminatorValue); },
+    };
+}
+export function serializeAvd(writer, avd = {}, isSerializingDerivedType = false) {
+    if (!avd || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("@odata.count", avd.odataCount);
+    writer.writeStringValue("@odata.nextLink", avd.odataNextLink);
+    writer.writeCollectionOfObjectValues("value", avd.value, serializeAvd_value);
+    writer.writeAdditionalData(avd.additionalData);
+}
+export function serializeAvd_value(writer, avd_value = {}, isSerializingDerivedType = false) {
+    if (!avd_value || isSerializingDerivedType) {
+        return;
+    }
+    serializeIntermediary(writer, avd_value, isSerializingDerivedType);
+    writer.writeObjectValue("properties", avd_value.properties, serializeAvdIntermediary);
+}

package/bin/sdk/shieldClient.d.ts

@@ -0,0 +1,24 @@
+import { type ApiRequestBuilder } from './api/index.js';
+import { type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
+/**
+ * Instantiates a new {@link ShieldClient} and sets the default values.
+ * @param requestAdapter The request adapter to use to execute the requests.
+ */
+export declare function createShieldClient(requestAdapter: RequestAdapter): ShieldClient;
+/**
+ * The main entry point of the SDK, exposes the configuration and the fluent API.
+ */
+export interface ShieldClient extends BaseRequestBuilder<ShieldClient> {
+    /**
+     * The Api property
+     */
+    get api(): ApiRequestBuilder;
+}
+/**
+ * Uri template for the request builder.
+ */
+export declare const ShieldClientUriTemplate = "{+baseurl}";
+/**
+ * Metadata for all the navigation properties in the request builder.
+ */
+export declare const ShieldClientNavigationMetadata: Record<Exclude<keyof ShieldClient, KeysToExcludeForNavigationMetadata>, NavigationMetadata>;

package/bin/sdk/shieldClient.js

@@ -0,0 +1,35 @@
+import { ApiRequestBuilderNavigationMetadata } from './api/index.js';
+import { apiClientProxifier } from '@microsoft/kiota-abstractions';
+import { FormParseNodeFactory, FormSerializationWriterFactory } from '@microsoft/kiota-serialization-form';
+import { JsonParseNodeFactory, JsonSerializationWriterFactory } from '@microsoft/kiota-serialization-json';
+import { MultipartSerializationWriterFactory } from '@microsoft/kiota-serialization-multipart';
+import { TextParseNodeFactory, TextSerializationWriterFactory } from '@microsoft/kiota-serialization-text';
+export function createShieldClient(requestAdapter) {
+    if (requestAdapter === undefined) {
+        throw new Error("requestAdapter cannot be undefined");
+    }
+    const serializationWriterFactory = requestAdapter.getSerializationWriterFactory();
+    const parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory();
+    const backingStoreFactory = requestAdapter.getBackingStoreFactory();
+    if (parseNodeFactoryRegistry.registerDefaultDeserializer) {
+        parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(TextParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(FormParseNodeFactory, backingStoreFactory);
+    }
+    if (serializationWriterFactory.registerDefaultSerializer) {
+        serializationWriterFactory.registerDefaultSerializer(JsonSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(TextSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(FormSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(MultipartSerializationWriterFactory);
+    }
+    const pathParameters = {
+        "baseurl": requestAdapter.baseUrl,
+    };
+    return apiClientProxifier(requestAdapter, pathParameters, ShieldClientNavigationMetadata, undefined);
+}
+export const ShieldClientUriTemplate = "{+baseurl}";
+export const ShieldClientNavigationMetadata = {
+    api: {
+        navigationMetadata: ApiRequestBuilderNavigationMetadata,
+    },
+};