honeyhive 0.6.0 → 0.6.2

package/dist/models/errors/createmodeleventbatch.d.ts

@@ -0,0 +1,14 @@
+import { AxiosResponse } from "axios";
+/**
+ * Model events partially created
+ */
+export declare class CreateModelEventBatchResponseBody extends Error {
+    eventIds?: string[];
+    errors?: string[];
+    success?: boolean;
+    /**
+     * Raw HTTP response; suitable for custom response parsing
+     */
+    rawResponse?: AxiosResponse;
+    constructor(err?: CreateModelEventBatchResponseBody);
+}

package/dist/models/{components/feedbackquery.js → errors/createmodeleventbatch.js}

@@ -27,37 +27,44 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeedbackQuery = void 0;
+exports.CreateModelEventBatchResponseBody = void 0;
 var utils_1 = require("../../internal/utils");
 var class_transformer_1 = require("class-transformer");
 /**
- * The request object for providing feedback
+ * Model events partially created
  */
-var FeedbackQuery = /** @class */ (function (_super) {
-    __extends(FeedbackQuery, _super);
-    function FeedbackQuery() {
-        return _super !== null && _super.apply(this, arguments) || this;
+var CreateModelEventBatchResponseBody = /** @class */ (function (_super) {
+    __extends(CreateModelEventBatchResponseBody, _super);
+    function CreateModelEventBatchResponseBody(err) {
+        var _this = _super.call(this) || this;
+        if (err) {
+            Object.assign(_this, err);
+            _this.message = JSON.stringify((0, class_transformer_1.classToPlain)(err, { exposeUnsetFields: false, excludeExtraneousValues: true }));
+        }
+        _this.name = "CreateModelEventBatchResponseBody";
+        Object.setPrototypeOf(_this, CreateModelEventBatchResponseBody.prototype);
+        return _this;
     }
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "task" }),
-        __metadata("design:type", String)
-    ], FeedbackQuery.prototype, "task", void 0);
+        (0, class_transformer_1.Expose)({ name: "event_ids" }),
+        __metadata("design:type", Array)
+    ], CreateModelEventBatchResponseBody.prototype, "eventIds", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "generation_id" }),
-        __metadata("design:type", String)
-    ], FeedbackQuery.prototype, "generationId", void 0);
+        (0, class_transformer_1.Expose)({ name: "errors" }),
+        __metadata("design:type", Array)
+    ], CreateModelEventBatchResponseBody.prototype, "errors", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "feedback_json" }),
-        __metadata("design:type", Object)
-    ], FeedbackQuery.prototype, "feedbackJson", void 0);
+        (0, class_transformer_1.Expose)({ name: "success" }),
+        __metadata("design:type", Boolean)
+    ], CreateModelEventBatchResponseBody.prototype, "success", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "ground_truth" }),
-        __metadata("design:type", String)
-    ], FeedbackQuery.prototype, "groundTruth", void 0);
-    return FeedbackQuery;
-}(utils_1.SpeakeasyBase));
-exports.FeedbackQuery = FeedbackQuery;
+        (0, class_transformer_1.Exclude)(),
+        __metadata("design:type", Object)
+    ], CreateModelEventBatchResponseBody.prototype, "rawResponse", void 0);
+    return CreateModelEventBatchResponseBody;
+}(Error));
+exports.CreateModelEventBatchResponseBody = CreateModelEventBatchResponseBody;

package/dist/models/errors/index.d.ts

@@ -1 +1,3 @@
+export * from "./createeventbatch";
+export * from "./createmodeleventbatch";
 export * from "./sdkerror";

package/dist/models/errors/index.js

@@ -17,4 +17,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createeventbatch"), exports);
+__exportStar(require("./createmodeleventbatch"), exports);
 __exportStar(require("./sdkerror"), exports);

package/dist/models/operations/adddatapoints.d.ts

@@ -0,0 +1,68 @@
+import { SpeakeasyBase } from "../../internal/utils";
+import { AxiosResponse } from "axios";
+/**
+ * Mapping of keys in the data object to be used as inputs, ground truth, and history, everything else goes into metadata
+ */
+export declare class Mapping extends SpeakeasyBase {
+    /**
+     * List of keys in the data object to be used as inputs
+     */
+    inputs: string[];
+    /**
+     * List of keys in the data object to be used as ground truth
+     */
+    groundTruth: string[];
+    /**
+     * List of keys in the data object to be used as chat history, can be empty list if not needed
+     */
+    history: string[];
+}
+export declare class AddDatapointsRequestBody extends SpeakeasyBase {
+    /**
+     * Name of the project associated with this dataset like `New Project`
+     */
+    project?: string;
+    /**
+     * List of JSON objects to be added as datapoints
+     */
+    data?: Record<string, any>[];
+    /**
+     * Mapping of keys in the data object to be used as inputs, ground truth, and history, everything else goes into metadata
+     */
+    mapping?: Mapping;
+}
+export declare class AddDatapointsRequest extends SpeakeasyBase {
+    /**
+     * The unique identifier of the dataset to add datapoints to like  `663876ec4611c47f4970f0c3`
+     */
+    datasetId: string;
+    requestBody: AddDatapointsRequestBody;
+}
+/**
+ * Successful addition
+ */
+export declare class AddDatapointsResponseBody extends SpeakeasyBase {
+    inserted?: boolean;
+    /**
+     * List of unique datapoint ids added to the dataset
+     */
+    datapointIds?: string[];
+}
+export declare class AddDatapointsResponse extends SpeakeasyBase {
+    /**
+     * HTTP response content type for this operation
+     */
+    contentType: string;
+    /**
+     * HTTP response status code for this operation
+     */
+    statusCode: number;
+    /**
+     * Raw HTTP response; suitable for custom response parsing
+     */
+    rawResponse: AxiosResponse;
+    /**
+     * Successful addition
+     */
+    object?: AddDatapointsResponseBody;
+}

package/dist/models/operations/adddatapoints.js

@@ -0,0 +1,143 @@
+"use strict";
+/*
+ * Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddDatapointsResponse = exports.AddDatapointsResponseBody = exports.AddDatapointsRequest = exports.AddDatapointsRequestBody = exports.Mapping = void 0;
+var utils_1 = require("../../internal/utils");
+var class_transformer_1 = require("class-transformer");
+/**
+ * Mapping of keys in the data object to be used as inputs, ground truth, and history, everything else goes into metadata
+ */
+var Mapping = /** @class */ (function (_super) {
+    __extends(Mapping, _super);
+    function Mapping() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "inputs" }),
+        __metadata("design:type", Array)
+    ], Mapping.prototype, "inputs", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "ground_truth" }),
+        __metadata("design:type", Array)
+    ], Mapping.prototype, "groundTruth", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "history" }),
+        __metadata("design:type", Array)
+    ], Mapping.prototype, "history", void 0);
+    return Mapping;
+}(utils_1.SpeakeasyBase));
+exports.Mapping = Mapping;
+var AddDatapointsRequestBody = /** @class */ (function (_super) {
+    __extends(AddDatapointsRequestBody, _super);
+    function AddDatapointsRequestBody() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "project" }),
+        __metadata("design:type", String)
+    ], AddDatapointsRequestBody.prototype, "project", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "data" }),
+        __metadata("design:type", Array)
+    ], AddDatapointsRequestBody.prototype, "data", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "mapping" }),
+        (0, class_transformer_1.Type)(function () { return Mapping; }),
+        __metadata("design:type", Mapping)
+    ], AddDatapointsRequestBody.prototype, "mapping", void 0);
+    return AddDatapointsRequestBody;
+}(utils_1.SpeakeasyBase));
+exports.AddDatapointsRequestBody = AddDatapointsRequestBody;
+var AddDatapointsRequest = /** @class */ (function (_super) {
+    __extends(AddDatapointsRequest, _super);
+    function AddDatapointsRequest() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)({ data: "pathParam, style=simple;explode=false;name=dataset_id" }),
+        __metadata("design:type", String)
+    ], AddDatapointsRequest.prototype, "datasetId", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)({ data: "request, media_type=application/json" }),
+        __metadata("design:type", AddDatapointsRequestBody)
+    ], AddDatapointsRequest.prototype, "requestBody", void 0);
+    return AddDatapointsRequest;
+}(utils_1.SpeakeasyBase));
+exports.AddDatapointsRequest = AddDatapointsRequest;
+/**
+ * Successful addition
+ */
+var AddDatapointsResponseBody = /** @class */ (function (_super) {
+    __extends(AddDatapointsResponseBody, _super);
+    function AddDatapointsResponseBody() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "inserted" }),
+        __metadata("design:type", Boolean)
+    ], AddDatapointsResponseBody.prototype, "inserted", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "datapoint_ids" }),
+        __metadata("design:type", Array)
+    ], AddDatapointsResponseBody.prototype, "datapointIds", void 0);
+    return AddDatapointsResponseBody;
+}(utils_1.SpeakeasyBase));
+exports.AddDatapointsResponseBody = AddDatapointsResponseBody;
+var AddDatapointsResponse = /** @class */ (function (_super) {
+    __extends(AddDatapointsResponse, _super);
+    function AddDatapointsResponse() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        __metadata("design:type", String)
+    ], AddDatapointsResponse.prototype, "contentType", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        __metadata("design:type", Number)
+    ], AddDatapointsResponse.prototype, "statusCode", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        __metadata("design:type", Object)
+    ], AddDatapointsResponse.prototype, "rawResponse", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        __metadata("design:type", AddDatapointsResponseBody)
+    ], AddDatapointsResponse.prototype, "object", void 0);
+    return AddDatapointsResponse;
+}(utils_1.SpeakeasyBase));
+exports.AddDatapointsResponse = AddDatapointsResponse;

package/dist/models/operations/createeventbatch.d.ts

@@ -0,0 +1,36 @@
+import { SpeakeasyBase } from "../../internal/utils";
+import * as components from "../../models/components";
+import { AxiosResponse } from "axios";
+export declare class CreateEventBatchRequestBody extends SpeakeasyBase {
+    events: components.CreateEventRequest[];
+    /**
+     * Default is false. If true, all events will be associated with the same session
+     */
+    isSingleSession?: boolean;
+}
+/**
+ * Events created
+ */
+export declare class CreateEventBatchResponseBody extends SpeakeasyBase {
+    eventIds?: string[];
+    sessionId?: string;
+    success?: boolean;
+}
+export declare class CreateEventBatchResponse extends SpeakeasyBase {
+    /**
+     * HTTP response content type for this operation
+     */
+    contentType: string;
+    /**
+     * HTTP response status code for this operation
+     */
+    statusCode: number;
+    /**
+     * Raw HTTP response; suitable for custom response parsing
+     */
+    rawResponse: AxiosResponse;
+    /**
+     * Events created
+     */
+    object?: CreateEventBatchResponseBody;
+}

package/dist/models/operations/{updatetask.js → createeventbatch.js}

@@ -50,49 +50,76 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateTaskResponse = exports.UpdateTaskRequestBody = void 0;
+exports.CreateEventBatchResponse = exports.CreateEventBatchResponseBody = exports.CreateEventBatchRequestBody = void 0;
 var utils_1 = require("../../internal/utils");
 var components = __importStar(require("../../models/components"));
 var class_transformer_1 = require("class-transformer");
-var UpdateTaskRequestBody = /** @class */ (function (_super) {
-    __extends(UpdateTaskRequestBody, _super);
-    function UpdateTaskRequestBody() {
+var CreateEventBatchRequestBody = /** @class */ (function (_super) {
+    __extends(CreateEventBatchRequestBody, _super);
+    function CreateEventBatchRequestBody() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)({ elemType: components.CreateEventRequest }),
+        (0, class_transformer_1.Expose)({ name: "events" }),
+        (0, class_transformer_1.Type)(function () { return components.CreateEventRequest; }),
+        __metadata("design:type", Array)
+    ], CreateEventBatchRequestBody.prototype, "events", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "description" }),
-        __metadata("design:type", String)
-    ], UpdateTaskRequestBody.prototype, "description", void 0);
+        (0, class_transformer_1.Expose)({ name: "is_single_session" }),
+        __metadata("design:type", Boolean)
+    ], CreateEventBatchRequestBody.prototype, "isSingleSession", void 0);
+    return CreateEventBatchRequestBody;
+}(utils_1.SpeakeasyBase));
+exports.CreateEventBatchRequestBody = CreateEventBatchRequestBody;
+/**
+ * Events created
+ */
+var CreateEventBatchResponseBody = /** @class */ (function (_super) {
+    __extends(CreateEventBatchResponseBody, _super);
+    function CreateEventBatchResponseBody() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "event_ids" }),
+        __metadata("design:type", Array)
+    ], CreateEventBatchResponseBody.prototype, "eventIds", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        (0, class_transformer_1.Expose)({ name: "task_id" }),
+        (0, class_transformer_1.Expose)({ name: "session_id" }),
         __metadata("design:type", String)
-    ], UpdateTaskRequestBody.prototype, "taskId", void 0);
-    return UpdateTaskRequestBody;
+    ], CreateEventBatchResponseBody.prototype, "sessionId", void 0);
+    __decorate([
+        (0, utils_1.SpeakeasyMetadata)(),
+        (0, class_transformer_1.Expose)({ name: "success" }),
+        __metadata("design:type", Boolean)
+    ], CreateEventBatchResponseBody.prototype, "success", void 0);
+    return CreateEventBatchResponseBody;
 }(utils_1.SpeakeasyBase));
-exports.UpdateTaskRequestBody = UpdateTaskRequestBody;
-var UpdateTaskResponse = /** @class */ (function (_super) {
-    __extends(UpdateTaskResponse, _super);
-    function UpdateTaskResponse() {
+exports.CreateEventBatchResponseBody = CreateEventBatchResponseBody;
+var CreateEventBatchResponse = /** @class */ (function (_super) {
+    __extends(CreateEventBatchResponse, _super);
+    function CreateEventBatchResponse() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", String)
-    ], UpdateTaskResponse.prototype, "contentType", void 0);
+    ], CreateEventBatchResponse.prototype, "contentType", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", Number)
-    ], UpdateTaskResponse.prototype, "statusCode", void 0);
+    ], CreateEventBatchResponse.prototype, "statusCode", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", Object)
-    ], UpdateTaskResponse.prototype, "rawResponse", void 0);
+    ], CreateEventBatchResponse.prototype, "rawResponse", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        __metadata("design:type", components.Task)
-    ], UpdateTaskResponse.prototype, "task", void 0);
-    return UpdateTaskResponse;
+        __metadata("design:type", CreateEventBatchResponseBody)
+    ], CreateEventBatchResponse.prototype, "object", void 0);
+    return CreateEventBatchResponse;
 }(utils_1.SpeakeasyBase));
-exports.UpdateTaskResponse = UpdateTaskResponse;
+exports.CreateEventBatchResponse = CreateEventBatchResponse;

package/dist/models/operations/{postevents.d.ts → createmodelevent.d.ts}

@@ -1,17 +1,17 @@
 import { SpeakeasyBase } from "../../internal/utils";
 import * as components from "../../models/components";
 import { AxiosResponse } from "axios";
-export declare class PostEventsRequestBody extends SpeakeasyBase {
-    event?: components.CreateEventRequest;
+export declare class CreateModelEventRequestBody extends SpeakeasyBase {
+    event?: components.CreateModelEvent;
 }
 /**
- * Event created
+ * Model event created
  */
-export declare class PostEventsResponseBody extends SpeakeasyBase {
+export declare class CreateModelEventResponseBody extends SpeakeasyBase {
     eventId?: string;
     success?: boolean;
 }
-export declare class PostEventsResponse extends SpeakeasyBase {
+export declare class CreateModelEventResponse extends SpeakeasyBase {
     /**
      * HTTP response content type for this operation
      */
@@ -25,7 +25,7 @@ export declare class PostEventsResponse extends SpeakeasyBase {
      */
     rawResponse: AxiosResponse;
     /**
-     * Event created
+     * Model event created
      */
-    object?: PostEventsResponseBody;
+    object?: CreateModelEventResponseBody;
 }

package/dist/models/operations/{postevents.js → createmodelevent.js}

@@ -50,66 +50,66 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostEventsResponse = exports.PostEventsResponseBody = exports.PostEventsRequestBody = void 0;
+exports.CreateModelEventResponse = exports.CreateModelEventResponseBody = exports.CreateModelEventRequestBody = void 0;
 var utils_1 = require("../../internal/utils");
 var components = __importStar(require("../../models/components"));
 var class_transformer_1 = require("class-transformer");
-var PostEventsRequestBody = /** @class */ (function (_super) {
-    __extends(PostEventsRequestBody, _super);
-    function PostEventsRequestBody() {
+var CreateModelEventRequestBody = /** @class */ (function (_super) {
+    __extends(CreateModelEventRequestBody, _super);
+    function CreateModelEventRequestBody() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         (0, class_transformer_1.Expose)({ name: "event" }),
-        (0, class_transformer_1.Type)(function () { return components.CreateEventRequest; }),
-        __metadata("design:type", components.CreateEventRequest)
-    ], PostEventsRequestBody.prototype, "event", void 0);
-    return PostEventsRequestBody;
+        (0, class_transformer_1.Type)(function () { return components.CreateModelEvent; }),
+        __metadata("design:type", components.CreateModelEvent)
+    ], CreateModelEventRequestBody.prototype, "event", void 0);
+    return CreateModelEventRequestBody;
 }(utils_1.SpeakeasyBase));
-exports.PostEventsRequestBody = PostEventsRequestBody;
+exports.CreateModelEventRequestBody = CreateModelEventRequestBody;
 /**
- * Event created
+ * Model event created
  */
-var PostEventsResponseBody = /** @class */ (function (_super) {
-    __extends(PostEventsResponseBody, _super);
-    function PostEventsResponseBody() {
+var CreateModelEventResponseBody = /** @class */ (function (_super) {
+    __extends(CreateModelEventResponseBody, _super);
+    function CreateModelEventResponseBody() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         (0, class_transformer_1.Expose)({ name: "event_id" }),
         __metadata("design:type", String)
-    ], PostEventsResponseBody.prototype, "eventId", void 0);
+    ], CreateModelEventResponseBody.prototype, "eventId", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         (0, class_transformer_1.Expose)({ name: "success" }),
         __metadata("design:type", Boolean)
-    ], PostEventsResponseBody.prototype, "success", void 0);
-    return PostEventsResponseBody;
+    ], CreateModelEventResponseBody.prototype, "success", void 0);
+    return CreateModelEventResponseBody;
 }(utils_1.SpeakeasyBase));
-exports.PostEventsResponseBody = PostEventsResponseBody;
-var PostEventsResponse = /** @class */ (function (_super) {
-    __extends(PostEventsResponse, _super);
-    function PostEventsResponse() {
+exports.CreateModelEventResponseBody = CreateModelEventResponseBody;
+var CreateModelEventResponse = /** @class */ (function (_super) {
+    __extends(CreateModelEventResponse, _super);
+    function CreateModelEventResponse() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", String)
-    ], PostEventsResponse.prototype, "contentType", void 0);
+    ], CreateModelEventResponse.prototype, "contentType", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", Number)
-    ], PostEventsResponse.prototype, "statusCode", void 0);
+    ], CreateModelEventResponse.prototype, "statusCode", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
         __metadata("design:type", Object)
-    ], PostEventsResponse.prototype, "rawResponse", void 0);
+    ], CreateModelEventResponse.prototype, "rawResponse", void 0);
     __decorate([
         (0, utils_1.SpeakeasyMetadata)(),
-        __metadata("design:type", PostEventsResponseBody)
-    ], PostEventsResponse.prototype, "object", void 0);
-    return PostEventsResponse;
+        __metadata("design:type", CreateModelEventResponseBody)
+    ], CreateModelEventResponse.prototype, "object", void 0);
+    return CreateModelEventResponse;
 }(utils_1.SpeakeasyBase));
-exports.PostEventsResponse = PostEventsResponse;
+exports.CreateModelEventResponse = CreateModelEventResponse;

package/dist/models/operations/{getsessionsessionidexport.d.ts → createmodeleventbatch.d.ts}

@@ -1,10 +1,17 @@
 import { SpeakeasyBase } from "../../internal/utils";
 import * as components from "../../models/components";
 import { AxiosResponse } from "axios";
-export declare class GetSessionSessionIdExportRequest extends SpeakeasyBase {
-    sessionId: string;
+export declare class CreateModelEventBatchRequestBody extends SpeakeasyBase {
+    modelEvents?: components.CreateModelEvent[];
 }
-export declare class GetSessionSessionIdExportResponse extends SpeakeasyBase {
+/**
+ * Model events created
+ */
+export declare class CreateModelEventBatchResponseBody extends SpeakeasyBase {
+    eventIds?: string[];
+    success?: boolean;
+}
+export declare class CreateModelEventBatchResponse extends SpeakeasyBase {
     /**
      * HTTP response content type for this operation
      */
@@ -18,7 +25,7 @@ export declare class GetSessionSessionIdExportResponse extends SpeakeasyBase {
      */
     rawResponse: AxiosResponse;
     /**
-     * OK
+     * Model events created
      */
-    traceEventTrace?: components.TraceEvent[];
+    object?: CreateModelEventBatchResponseBody;
 }