[TypeScript] Untyped Nodes

packages/abstractions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-abstractions",
-  "version": "1.0.0-preview.44",
+  "version": "1.0.0-preview.45",
   "description": "Core abstractions for kiota generated libraries in TypeScript and JavaScript",
   "main": "dist/cjs/src/index.js",
   "module": "dist/es/src/index.js",

packages/abstractions/src/serialization/index.ts

@@ -12,3 +12,10 @@ export * from "./serializationWriterFactory";
 export * from "./serializationWriterFactoryRegistry";
 export * from "./serializationWriterProxyFactory";
 export * from "./serializationFunctionTypes";
+export * from "./untypedNode";
+export * from "./untypedNumber";
+export * from "./untypedArray";
+export * from "./untypedNull";
+export * from "./untypedObject";
+export * from "./untypedString";
+export * from "./untypedBoolean";

packages/abstractions/src/serialization/untypedArray.ts

@@ -0,0 +1,19 @@
+import { isUntypedNode, UntypedNode } from "./untypedNode";
+
+export class UntypedArray extends UntypedNode {
+  constructor(value: UntypedNode[]) {
+    super(value);
+  }
+  getValue(): UntypedNode[] {
+    return this.value as UntypedNode[];
+  }
+}
+
+export function isUntypedArray(node: UntypedNode): node is UntypedArray {
+  const proposedNode = node as UntypedArray;
+  return (
+    proposedNode &&
+    proposedNode.value instanceof Array &&
+    proposedNode.value.every((item) => isUntypedNode(item))
+  );
+}

packages/abstractions/src/serialization/untypedBoolean.ts

@@ -0,0 +1,14 @@
+import { UntypedNode } from "./untypedNode";
+
+export class UntypedBoolean extends UntypedNode {
+  constructor(value: boolean) {
+    super(value);
+  }
+  getValue(): boolean {
+    return this.value as boolean;
+  }
+}
+
+export function isUntypedBoolean(node: UntypedNode): node is UntypedBoolean {
+  return typeof (node as UntypedBoolean)?.value === "boolean";
+}

packages/abstractions/src/serialization/untypedNode.ts

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { Parsable } from "./parsable";
+import type { ParseNode } from "./parseNode";
+import type { SerializationWriter } from "./serializationWriter";
+
+export class UntypedNode implements Parsable {
+  constructor(value?: any) {
+    this.value = value;
+  }
+  getValue(): any {
+    return this.value;
+  }
+  value?: any;
+}
+
+export function createUntypedNodeFromDiscriminatorValue(
+  _parseNode: ParseNode | undefined,
+): (instance?: Parsable) => Record<string, (node: ParseNode) => void> {
+  return deserializeIntoUntypedNode;
+}
+
+export function isUntypedNode(node: any): node is UntypedNode {
+  const potentialNode = node as UntypedNode;
+  return potentialNode && potentialNode.getValue !== undefined;
+}
+
+export function deserializeIntoUntypedNode(
+  untypedNode: Partial<UntypedNode> | undefined = {},
+): Record<string, (node: ParseNode) => void> {
+  return {
+    value: (n) => {
+      untypedNode.value = null;
+    },
+    getValue: (n) => {
+      untypedNode.getValue = () => untypedNode.value;
+    },
+  };
+}
+
+export function serializeUntypedNode(
+  _writer: SerializationWriter,
+  _errorDetails: Partial<UntypedNode> | undefined = {},
+): void {
+  return;
+}

packages/abstractions/src/serialization/untypedNull.ts

@@ -0,0 +1,14 @@
+import { UntypedNode } from "./untypedNode";
+
+export class UntypedNull extends UntypedNode {
+  constructor() {
+    super(null);
+  }
+  getValue(): null {
+    return null;
+  }
+}
+
+export function isUntypedNull(node: UntypedNode): node is UntypedNull {
+  return (node as UntypedNull)?.value === null;
+}

packages/abstractions/src/serialization/untypedNumber.ts

@@ -0,0 +1,14 @@
+import { UntypedNode } from "./untypedNode";
+
+export class UntypedNumber extends UntypedNode {
+  constructor(value: number) {
+    super(value);
+  }
+  getValue(): number {
+    return this.value as number;
+  }
+}
+
+export function isUntypedNumber(node: UntypedNode): node is UntypedNumber {
+  return typeof (node as UntypedNumber)?.value === "number";
+}

packages/abstractions/src/serialization/untypedObject.ts

@@ -0,0 +1,19 @@
+import { isUntypedNode, UntypedNode } from "./untypedNode";
+
+export class UntypedObject extends UntypedNode {
+  constructor(value: Record<string, UntypedNode>) {
+    super(value);
+  }
+  getValue(): Record<string, UntypedNode> {
+    return this.value as Record<string, UntypedNode>;
+  }
+}
+
+export function isUntypedObject(node: UntypedNode): node is UntypedObject {
+  const value = (node as UntypedObject)?.value;
+  return (
+    value instanceof Object &&
+    value instanceof Array === false &&
+    Object.values(value).every((item) => isUntypedNode(item))
+  );
+}

packages/abstractions/src/serialization/untypedString.ts

@@ -0,0 +1,14 @@
+import { UntypedNode } from "./untypedNode";
+
+export class UntypedString extends UntypedNode {
+  constructor(value: string) {
+    super(value);
+  }
+  getValue(): string {
+    return this.value as string;
+  }
+}
+
+export function isUntypedString(node: UntypedNode): node is UntypedString {
+  return typeof (node as UntypedString)?.value === "string";
+}

packages/authentication/azure/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-authentication-azure",
-  "version": "1.0.0-preview.39",
+  "version": "1.0.0-preview.40",
   "description": "Authentication provider for Kiota using Azure Identity",
   "main": "dist/cjs/src/index.js",
   "module": "dist/es/src/index.js",
@@ -30,7 +30,7 @@
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
     "@azure/core-auth": "^1.5.0",
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "@opentelemetry/api": "^1.7.0",
     "tslib": "^2.6.2"
   },

packages/authentication/spfx/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-authentication-spfx",
-  "version": "1.0.0-preview.34",
+  "version": "1.0.0-preview.35",
   "description": "Authentication provider for using Kiota in SPFx solutions",
   "main": "dist/cjs/src/index.js",
   "module": "dist/es/src/index.js",
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "@microsoft/sp-http": "^1.15.2",
     "@opentelemetry/api": "^1.7.0",
     "tslib": "^2.6.2"

packages/http/fetch/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microsoft/kiota-http-fetchlibrary",
-	"version": "1.0.0-preview.43",
+	"version": "1.0.0-preview.44",
 	"description": "Kiota request adapter implementation with fetch",
 	"keywords": [
 		"Kiota",
@@ -38,7 +38,7 @@
 		"test:cjs": "mocha 'dist/cjs/test/common/**/*.js' && mocha  'dist/cjs/test/node/**/*.js'"
 	},
 	"dependencies": {
-		"@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+		"@microsoft/kiota-abstractions": "^1.0.0-preview.45",
 		"@opentelemetry/api": "^1.7.0",
 		"guid-typescript": "^1.0.9",
 		"tslib": "^2.6.2"

packages/serialization/form/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-serialization-form",
-  "version": "1.0.0-preview.33",
+  "version": "1.0.0-preview.34",
   "description": "Implementation of Kiota Serialization interfaces for URI from encoded",
   "main": "dist/cjs/src/index.js",
   "browser": {
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "guid-typescript": "^1.0.9",
     "tslib": "^2.6.2"
   },

packages/serialization/json/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-serialization-json",
-  "version": "1.0.0-preview.44",
+  "version": "1.0.0-preview.45",
   "description": "Implementation of Kiota Serialization interfaces for JSON",
   "main": "dist/cjs/src/index.js",
   "browser": {
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "guid-typescript": "^1.0.9",
     "tslib": "^2.6.2"
   },

packages/serialization/json/src/jsonParseNode.ts

@@ -9,6 +9,15 @@ import {
   TimeOnly,
   isBackingStoreEnabled,
   toFirstCharacterUpper,
+  isUntypedNode,
+  UntypedNode,
+  UntypedArray,
+  UntypedBoolean,
+  UntypedNumber,
+  UntypedObject,
+  UntypedString,
+  createUntypedNodeFromDiscriminatorValue,
+  UntypedNull,
 } from "@microsoft/kiota-abstractions";
 
 export class JsonParseNode implements ParseNode {
@@ -72,6 +81,39 @@ export class JsonParseNode implements ParseNode {
     parsableFactory: ParsableFactory<T>,
   ): T => {
     const temp: T = {} as T;
+    if (isUntypedNode(parsableFactory(this)(temp))) {
+      const valueType = typeof this._jsonNode;
+      let value: T = temp;
+      if (valueType === "boolean") {
+        value = new UntypedBoolean(this._jsonNode as boolean) as any as T;
+      } else if (valueType === "string") {
+        value = new UntypedString(this._jsonNode as string) as any as T;
+      } else if (valueType === "number") {
+        value = new UntypedNumber(this._jsonNode as number) as any as T;
+      } else if (Array.isArray(this._jsonNode)) {
+        const nodes: UntypedNode[] = [];
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        (this._jsonNode as any[]).forEach((x) => {
+          nodes.push(
+            new JsonParseNode(x).getObjectValue(
+              createUntypedNodeFromDiscriminatorValue,
+            ),
+          );
+        });
+        value = new UntypedArray(nodes) as any as T;
+      } else if (this._jsonNode && valueType === "object") {
+        const properties: Record<string, UntypedNode> = {};
+        Object.entries(this._jsonNode as any).forEach(([k, v]) => {
+          properties[k] = new JsonParseNode(v).getObjectValue(
+            createUntypedNodeFromDiscriminatorValue,
+          );
+        });
+        value = new UntypedObject(properties) as any as T;
+      } else if (!this._jsonNode) {
+        value = new UntypedNull() as any as T;
+      }
+      return value;
+    }
     const enableBackingStore = isBackingStoreEnabled(parsableFactory(this)(temp));
     const value: T = enableBackingStore ? new Proxy(temp, createBackedModelProxyHandler<T>()) : temp;
     if (this.onBeforeAssignFieldValues) {

packages/serialization/json/src/jsonSerializationWriter.ts

@@ -2,10 +2,19 @@
 import {
   DateOnly,
   Duration,
+  isUntypedNode,
   type ModelSerializerFunction,
   type Parsable,
   type SerializationWriter,
-  TimeOnly} from "@microsoft/kiota-abstractions";
+  TimeOnly,
+  type UntypedNode,
+  isUntypedBoolean,
+  isUntypedString,
+  isUntypedNull,
+  isUntypedNumber,
+  isUntypedObject,
+  isUntypedArray,
+} from "@microsoft/kiota-abstractions";
 import type { Guid } from "guid-typescript";
 
 export class JsonSerializationWriter implements SerializationWriter {
@@ -103,12 +112,72 @@ export class JsonSerializationWriter implements SerializationWriter {
     value: T,
     serializerMethod: ModelSerializerFunction<T>,
   ): void {
-    if (key) {
+    if (isUntypedNode(value)) {
+      const untypedNode = value as UntypedNode;
+      if (isUntypedBoolean(untypedNode)) {
+        this.writeBooleanValue(key, untypedNode.getValue());
+      } else if (isUntypedString(untypedNode)) {
+        this.writeStringValue(key, untypedNode.getValue());
+      } else if (isUntypedNull(untypedNode)) {
+        this.writeNullValue(key);
+      } else if (isUntypedNumber(untypedNode)) {
+        this.writeNumberValue(key, untypedNode.getValue());
+      } else if (isUntypedObject(untypedNode)) {
+        const value = untypedNode.getValue();
+        if (key && value) {
+          this.writePropertyName(key);
+        }
+        value && this.writer.push(`{`);
+        for (const key in value) {
+          this.writeObjectValue(
+            key,
+            value[key] as unknown as T,
+            serializerMethod,
+          );
+        }
+        if (
+          this.writer.length > 0 &&
+          this.writer[this.writer.length - 1] ===
+            JsonSerializationWriter.propertySeparator
+        ) {
+          //removing the last separator
+          this.writer.pop();
+        }
+        value && this.writer.push(`}`);
+        key && this.writer.push(JsonSerializationWriter.propertySeparator);
+      } else if (isUntypedArray(untypedNode)) {
+        if (key) {
+          this.writePropertyName(key);
+        }
+        const value = untypedNode.getValue();
+        this.writer.push(`[`);
+        value.forEach((v, idx) => {
+          this.writeObjectValue(undefined, v as unknown as T, serializerMethod);
+          idx + 1 < value.length &&
+            this.writer.push(JsonSerializationWriter.propertySeparator);
+        });
+        if (
+          this.writer.length > 0 &&
+          this.writer[this.writer.length - 1] ===
+            JsonSerializationWriter.propertySeparator
+        ) {
+          //removing the last separator
+          this.writer.pop();
+        }
+        this.writer.push(`]`);
+        key && this.writer.push(JsonSerializationWriter.propertySeparator);
+      } else {
+        this.writeAnyValue(key, untypedNode.getValue());
+      }
+      return; // nothing to do here, the value has been written
+    }
+
+    if (key && value) {
       this.writePropertyName(key);
     }
     this.onBeforeObjectSerialization &&
       this.onBeforeObjectSerialization(value as unknown as Parsable);
-    this.writer.push(`{`);
+    value && this.writer.push(`{`);
 
     this.onStartObjectSerialization &&
       this.onStartObjectSerialization(value as unknown as Parsable, this);
@@ -124,7 +193,7 @@ export class JsonSerializationWriter implements SerializationWriter {
       //removing the last separator
       this.writer.pop();
     }
-    this.writer.push(`}`);
+    value && this.writer.push(`}`);
 
     key && this.writer.push(JsonSerializationWriter.propertySeparator);
   }

packages/serialization/json/test/common/JsonParseNode.ts

@@ -1,12 +1,13 @@
 import { assert } from "chai";
-
 import { JsonParseNode } from "../../src/index";
 import {
   createTestParserFromDiscriminatorValue,
   type TestBackedModel,
   createTestBackedModelFromDiscriminatorValue,
   type TestParser 
 } from "./testEntity";
+import { UntypedTestEntity, createUntypedTestEntityFromDiscriminatorValue } from "./untypedTestEntiy";
+import { UntypedNode, UntypedObject, isUntypedArray, isUntypedBoolean, isUntypedNode, isUntypedNumber, isUntypedObject } from "@microsoft/kiota-abstractions";
 
 describe("JsonParseNode", () => {
   it("jsonParseNode:initializes", async () => {
@@ -169,4 +170,72 @@ describe("JsonParseNode", () => {
     assert.equal(jsonObjectStr, resultStr);
   });
 
+  it("untyped nodes are deserialized correctly", async () => {
+    const jsonObject = {
+      id: "1",
+      title: "title",
+      location: {
+        address: {
+          city: "Redmond",
+          postalCode: "98052",
+          state: "Washington",
+          street: "NE 36th St",
+        },
+        coordinates: {
+          latitude: 47.678581,
+          longitude: -122.131577,
+        },
+        displayName: "Microsoft Building 25",
+        floorCount: 50,
+        hasReception: true,
+        contact: null,
+      },
+      keywords: [
+        {
+          created: "2023-07-26T10:41:26Z",
+          label: "Keyword1",
+          termGuid: "10e9cc83-b5a4-4c8d-8dab-4ada1252dd70",
+          wssId: 6442450941,
+        },
+        {
+          created: "2023-07-26T10:51:26Z",
+          label: "Keyword2",
+          termGuid: "2cae6c6a-9bb8-4a78-afff-81b88e735fef",
+          wssId: 6442450942,
+        },
+      ],
+      extra: {
+        value: {
+          createdDateTime: {
+            value: "2024-01-15T00:00:00+00:00",
+          },
+        },
+      },
+    };
+
+    const result = new JsonParseNode(jsonObject).getObjectValue(
+      createUntypedTestEntityFromDiscriminatorValue,
+    ) as UntypedTestEntity;
+    assert.equal(result.id, "1");
+    assert.equal(result.title, "title");
+    assert.isNotNull(result.location);
+    assert.isTrue(isUntypedNode(result.location));
+    const location = result.location as UntypedObject;
+    const locationProperties = location.getValue();
+    assert.isTrue(isUntypedObject(location));
+    assert.isTrue(isUntypedObject(locationProperties["address"]));
+    assert.isTrue(isUntypedObject(locationProperties["coordinates"]));
+    assert.isTrue(isUntypedBoolean(locationProperties["hasReception"]));
+    assert.isTrue(isUntypedNumber(locationProperties["floorCount"]));
+    assert.isTrue(isUntypedBoolean(locationProperties["hasReception"]));
+    assert.equal(locationProperties["hasReception"].getValue(), true);
+    assert.equal(locationProperties["contact"].getValue(), null);
+    assert.equal(locationProperties["floorCount"].getValue(), 50);
+    const keywords = result.keywords as UntypedNode;
+    assert.isTrue(isUntypedArray(keywords));
+    assert.equal(
+      locationProperties["displayName"].getValue(),
+      "Microsoft Building 25",
+    );
+  });
 });

packages/serialization/json/test/common/jsonSerializationWriter.ts

@@ -6,6 +6,8 @@ import {
   serializeTestParser,
   type TestParser,
 } from "./testEntity";
+import { UntypedTestEntity, serializeUntypedTestEntity } from "./untypedTestEntiy";
+import { UntypedArray, UntypedBoolean, UntypedNull, UntypedNumber, UntypedObject, UntypedString } from "@microsoft/kiota-abstractions";
 
 describe("JsonParseNode", () => {
   it("Test object serialization", async () => {
@@ -76,4 +78,54 @@ describe("JsonParseNode", () => {
     const result = JSON.parse(contentAsStr);
     assert.equal(result.testComplexString, "Błonie");
   });
+  it("serializes untyped nodes as expected", async () => {
+    const inputObject: UntypedTestEntity = {
+      id: "1",
+      title: "title",
+      location: new UntypedObject({
+        address: new UntypedObject({
+          city: new UntypedString("Redmond"),
+          postalCode: new UntypedString("98052"),
+          state: new UntypedString("Washington"),
+          street: new UntypedString("NE 36th St"),
+        }),
+        coordinates: new UntypedObject({
+          latitude: new UntypedNumber(47.678581),
+          longitude: new UntypedNumber(-122.131577),
+        }),
+        displayName: new UntypedString("Microsoft Building 25"),
+        floorCount: new UntypedNumber(50),
+        hasReception: new UntypedBoolean(true),
+        contact: new UntypedNull(),
+      }),
+      keywords: new UntypedArray([
+        new UntypedObject({
+          created: new UntypedString("2023-07-26T10:41:26Z"),
+          label: new UntypedString("Keyword1"),
+          termGuid: new UntypedString("10e9cc83-b5a4-4c8d-8dab-4ada1252dd70"),
+          wssId: new UntypedNumber(6442450941),
+        }),
+        new UntypedObject({
+          created: new UntypedString("2023-07-26T10:51:26Z"),
+          label: new UntypedString("Keyword2"),
+          termGuid: new UntypedString("2cae6c6a-9bb8-4a78-afff-81b88e735fef"),
+          wssId: new UntypedNumber(6442450942),
+        }),
+      ]),
+      additionalData: {
+        extra: new UntypedObject({
+          createdDateTime: new UntypedString("2024-01-15T00:00:00+00:00"),
+        }),
+      },
+    };
+    const writer = new JsonSerializationWriter();
+    writer.writeObjectValue("", inputObject, serializeUntypedTestEntity);
+    const serializedContent = writer.getSerializedContent();
+    const decoder = new TextDecoder();
+    const contentAsStr = decoder.decode(serializedContent);
+    assert.equal(
+      '{"id":"1","title":"title","location":{"address":{"city":"Redmond","postalCode":"98052","state":"Washington","street":"NE 36th St"},"coordinates":{"latitude":47.678581,"longitude":-122.131577},"displayName":"Microsoft Building 25","floorCount":50,"hasReception":true,"contact":null},"keywords":[{"created":"2023-07-26T10:41:26Z","label":"Keyword1","termGuid":"10e9cc83-b5a4-4c8d-8dab-4ada1252dd70","wssId":6442450941},{"created":"2023-07-26T10:51:26Z","label":"Keyword2","termGuid":"2cae6c6a-9bb8-4a78-afff-81b88e735fef","wssId":6442450942}],"extra":{"value":{"createdDateTime":{"value":"2024-01-15T00:00:00+00:00"}}}}',
+      contentAsStr,
+    );
+  });
 });

packages/serialization/json/test/common/untypedTestEntiy.ts

@@ -0,0 +1,62 @@
+import {
+  createUntypedNodeFromDiscriminatorValue,
+  SerializationWriter,
+  type ParseNode,
+  type UntypedNode,
+} from "@microsoft/kiota-abstractions";
+
+export interface UntypedTestEntity {
+  id?: string | undefined;
+  title?: string | undefined;
+  location?: UntypedNode | undefined;
+  keywords?: UntypedNode | undefined;
+  detail?: UntypedNode | undefined;
+  additionalData?: Record<string, unknown>;
+}
+
+export function createUntypedTestEntityFromDiscriminatorValue(
+  parseNode: ParseNode | undefined,
+) {
+  if (!parseNode) throw new Error("parseNode cannot be undefined");
+  return deserializeUntypedTestEntity;
+}
+
+export function deserializeUntypedTestEntity(
+  untypedTestEntity: UntypedTestEntity | undefined = {},
+): Record<string, (node: ParseNode) => void> {
+  return {
+    id: (n) => {
+      untypedTestEntity.id = n.getStringValue();
+    },
+    title: (n) => {
+      untypedTestEntity.title = n.getStringValue();
+    },
+    location: (n) => {
+      untypedTestEntity.location = n.getObjectValue<UntypedNode>(
+        createUntypedNodeFromDiscriminatorValue,
+      );
+    },
+    keywords: (n) => {
+      untypedTestEntity.keywords = n.getObjectValue<UntypedNode>(
+        createUntypedNodeFromDiscriminatorValue,
+      );
+    },
+    detail: (n) => {
+      untypedTestEntity.detail = n.getObjectValue<UntypedNode>(
+        createUntypedNodeFromDiscriminatorValue,
+      );
+    },
+  };
+}
+
+export function serializeUntypedTestEntity(
+  writer: SerializationWriter,
+  untypedTestEntity: UntypedTestEntity | undefined = {},
+): void {
+  writer.writeStringValue("id", untypedTestEntity.id);
+  writer.writeStringValue("title", untypedTestEntity.title);
+  writer.writeObjectValue("location", untypedTestEntity.location);
+  writer.writeObjectValue("keywords", untypedTestEntity.keywords);
+  writer.writeObjectValue("detail", untypedTestEntity.detail);
+  writer.writeAdditionalData(untypedTestEntity.additionalData);
+}

packages/serialization/multipart/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-serialization-multipart",
-  "version": "1.0.0-preview.23",
+  "version": "1.0.0-preview.24",
   "description": "Implementation of Kiota Serialization interfaces for multipart form data",
   "main": "dist/cjs/src/index.js",
   "module": "dist/es/src/index.js",
@@ -35,7 +35,7 @@
   },
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "guid-typescript": "^1.0.9",
     "tslib": "^2.6.2"
   },

packages/serialization/text/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/kiota-serialization-text",
-  "version": "1.0.0-preview.41",
+  "version": "1.0.0-preview.42",
   "description": "Implementation of Kiota Serialization interfaces for text",
   "main": "dist/cjs/src/index.js",
   "browser": {
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/microsoft/kiota-typescript#readme",
   "dependencies": {
-    "@microsoft/kiota-abstractions": "^1.0.0-preview.44",
+    "@microsoft/kiota-abstractions": "^1.0.0-preview.45",
     "guid-typescript": "^1.0.9",
     "tslib": "^2.6.2"
   },