@camunda8/sdk 8.4.0 → 8.4.1

package/dist/operate/lib/OperateDto.d.ts

@@ -0,0 +1,126 @@
+import { LosslessNumber } from 'lossless-json';
+import { LosslessDto } from '../../lib';
+export declare class DecisionDefinition extends LosslessDto {
+    id: string;
+    key: string;
+    decisionId: string;
+    name: string;
+    version: number;
+    decisionRequirementsId: string;
+    decisionRequirementsKey: string;
+    decisionRequirementsName: string;
+    decisionRequirementsVersion: number;
+    tenantId: string | undefined;
+}
+export declare class DecisionInstanceInput extends LosslessDto {
+    id: string;
+    name: string;
+    value: string;
+}
+export declare class DecisionInstanceOutput extends LosslessDto {
+    id: string;
+    name: string;
+    value: string;
+    ruleId: string;
+    ruleIndex: number;
+}
+export declare class DecisionInstance extends LosslessDto {
+    id: string;
+    key: string;
+    state: 'FAILED' | 'EVALUATED' | 'UNKNOWN' | 'UNSPECIFIED';
+    evaluationDate: string;
+    evaluationFailure: string;
+    processDefinitionKey: string;
+    decisionId: string;
+    decisionDefinitionId: string;
+    decisionName: string;
+    decisionVersion: number;
+    decisionType: 'DECISION_TABLE' | 'LITERAL_EXPRESSION' | 'UNSPECIFIED' | 'UNKNOWN';
+    result: string;
+    evaluatedInputs: DecisionInstanceInput[];
+    evaluatedOutputs: DecisionInstanceOutput[];
+    tenantId: string | undefined;
+}
+export declare class DecisionRequirements extends LosslessDto {
+    id: string;
+    key: string;
+    decisionRequirementsId: string;
+    name: string;
+    version: number;
+    resourceName: string;
+    tenantId: string | undefined;
+}
+export declare class ProcessDefinition extends LosslessDto {
+    /** ProcessDefinition key is a string in the SDK, but it's an int64 number in the database */
+    key: string;
+    name: string;
+    version: number;
+    bpmnProcessId: string;
+}
+export declare class ProcessInstance extends LosslessDto {
+    key: string;
+    processVersion: number;
+    bpmnProcessId: string;
+    parentKey?: string;
+    parentFlowNodeInstanceKey?: string;
+    startDate: string;
+    endDate: string;
+    state: 'ACTIVE' | 'COMPLETED' | 'CANCELED';
+    processDefinitionKey: string;
+    tenantId: string | undefined;
+}
+export declare class Incident extends LosslessDto {
+    key: string;
+    processDefinitionKey: LosslessNumber;
+    processInstanceKey: LosslessNumber;
+    type: 'UNSPECIFIED' | 'UNKNOWN' | 'IO_MAPPING_ERROR' | 'JOB_NO_RETRIES' | 'CONDITION_ERROR' | 'EXTRACT_VALUE_ERROR' | 'CALLED_ELEMENT_ERROR' | 'UNHANDLED_ERROR_EVENT' | 'MESSAGE_SIZE_EXCEEDED' | 'CALLED_DECISION_ERROR' | 'DECISION_EVALUATION_ERROR';
+    message: string;
+    creationTime: string;
+    state: 'ACTIVE' | 'RESOLVED';
+    jobKey: string;
+    tenantId: string | undefined;
+}
+export declare class FlownodeInstance extends LosslessDto {
+    key: string;
+    processInstanceKey: string;
+    startDate: string;
+    endDate: string;
+    incidentKey?: string;
+    type: 'UNSPECIFIED' | 'PROCESS' | 'SUB_PROCESS' | 'EVENT_SUB_PROCESS' | 'START_EVENT' | 'INTERMEDIATE_CATCH_EVENT' | 'INTERMEDIATE_THROW_EVENT' | 'BOUNDARY_EVENT' | 'END_EVENT' | 'SERVICE_TASK' | 'RECEIVE_TASK' | 'USER_TASK' | 'MANUAL_TASK' | 'TASK' | 'EXCLUSIVE_GATEWAY' | 'INCLUSIVE_GATEWAY' | 'PARALLEL_GATEWAY' | 'EVENT_BASED_GATEWAY' | 'SEQUENCE_FLOW' | 'MULTI_INSTANCE_BODY' | 'CALL_ACTIVITY' | 'BUSINESS_RULE_TASK' | 'SCRIPT_TASK' | 'SEND_TASK' | 'UNKNOWN';
+    state: 'ACTIVE' | 'COMPLETED' | 'TERMINATED';
+    incident: boolean;
+    tenantId: string | undefined;
+}
+export declare class Variable extends LosslessDto {
+    key: string;
+    processInstanceKey: string;
+    scopeKey: string;
+    name: string;
+    value: string;
+    truncated: boolean;
+}
+export declare class ChangeStatus extends LosslessDto {
+    message: string;
+    deleted: string;
+}
+export declare class ProcessInstanceStatistics extends LosslessDto {
+    activityId: string;
+    active: string;
+    canceled: string;
+    incidents: string;
+    completed: string;
+}
+export interface Query<T> {
+    filter?: Partial<T>;
+    size?: number;
+    sort?: [{
+        field: keyof T;
+        order: 'ASC' | 'DESC';
+    }];
+    searchAfter?: unknown[];
+}
+export interface SearchResults<T> {
+    items: T[];
+    sortValues: unknown[];
+    total: string;
+}

package/dist/operate/lib/OperateDto.js

@@ -0,0 +1,125 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessInstanceStatistics = exports.ChangeStatus = exports.Variable = exports.FlownodeInstance = exports.Incident = exports.ProcessInstance = exports.ProcessDefinition = exports.DecisionRequirements = exports.DecisionInstance = exports.DecisionInstanceOutput = exports.DecisionInstanceInput = exports.DecisionDefinition = void 0;
+const lib_1 = require("../../lib");
+class DecisionDefinition extends lib_1.LosslessDto {
+}
+exports.DecisionDefinition = DecisionDefinition;
+__decorate([
+    lib_1.Int64String
+], DecisionDefinition.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], DecisionDefinition.prototype, "decisionRequirementsKey", void 0);
+class DecisionInstanceInput extends lib_1.LosslessDto {
+}
+exports.DecisionInstanceInput = DecisionInstanceInput;
+class DecisionInstanceOutput extends lib_1.LosslessDto {
+}
+exports.DecisionInstanceOutput = DecisionInstanceOutput;
+class DecisionInstance extends lib_1.LosslessDto {
+}
+exports.DecisionInstance = DecisionInstance;
+__decorate([
+    lib_1.Int64String
+], DecisionInstance.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], DecisionInstance.prototype, "processDefinitionKey", void 0);
+__decorate([
+    (0, lib_1.ChildDto)(DecisionInstanceOutput)
+], DecisionInstance.prototype, "evaluatedOutputs", void 0);
+class DecisionRequirements extends lib_1.LosslessDto {
+}
+exports.DecisionRequirements = DecisionRequirements;
+__decorate([
+    lib_1.Int64String
+], DecisionRequirements.prototype, "key", void 0);
+class ProcessDefinition extends lib_1.LosslessDto {
+}
+exports.ProcessDefinition = ProcessDefinition;
+__decorate([
+    lib_1.Int64String
+], ProcessDefinition.prototype, "key", void 0);
+class ProcessInstance extends lib_1.LosslessDto {
+}
+exports.ProcessInstance = ProcessInstance;
+__decorate([
+    lib_1.Int64String
+], ProcessInstance.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstance.prototype, "parentKey", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstance.prototype, "parentFlowNodeInstanceKey", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstance.prototype, "processDefinitionKey", void 0);
+class Incident extends lib_1.LosslessDto {
+}
+exports.Incident = Incident;
+__decorate([
+    lib_1.Int64String
+], Incident.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], Incident.prototype, "processDefinitionKey", void 0);
+__decorate([
+    lib_1.Int64String
+], Incident.prototype, "processInstanceKey", void 0);
+__decorate([
+    lib_1.Int64String
+], Incident.prototype, "jobKey", void 0);
+class FlownodeInstance extends lib_1.LosslessDto {
+}
+exports.FlownodeInstance = FlownodeInstance;
+__decorate([
+    lib_1.Int64String
+], FlownodeInstance.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], FlownodeInstance.prototype, "processInstanceKey", void 0);
+__decorate([
+    lib_1.Int64String
+], FlownodeInstance.prototype, "incidentKey", void 0);
+class Variable extends lib_1.LosslessDto {
+}
+exports.Variable = Variable;
+__decorate([
+    lib_1.Int64String
+], Variable.prototype, "key", void 0);
+__decorate([
+    lib_1.Int64String
+], Variable.prototype, "processInstanceKey", void 0);
+__decorate([
+    lib_1.Int64String
+], Variable.prototype, "scopeKey", void 0);
+class ChangeStatus extends lib_1.LosslessDto {
+}
+exports.ChangeStatus = ChangeStatus;
+__decorate([
+    lib_1.Int64String
+], ChangeStatus.prototype, "deleted", void 0);
+class ProcessInstanceStatistics extends lib_1.LosslessDto {
+}
+exports.ProcessInstanceStatistics = ProcessInstanceStatistics;
+__decorate([
+    lib_1.Int64String
+], ProcessInstanceStatistics.prototype, "active", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstanceStatistics.prototype, "canceled", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstanceStatistics.prototype, "incidents", void 0);
+__decorate([
+    lib_1.Int64String
+], ProcessInstanceStatistics.prototype, "completed", void 0);
+//# sourceMappingURL=OperateDto.js.map

package/dist/operate/lib/OperateDto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperateDto.js","sourceRoot":"","sources":["../../../src/operate/lib/OperateDto.ts"],"names":[],"mappings":";;;;;;;;;AAEA,mCAA8D;AAE9D,MAAa,kBAAmB,SAAQ,iBAAW;CAalD;AAbD,gDAaC;AAVA;IADC,iBAAW;+CACA;AAMZ;IADC,iBAAW;mEACoB;AAMjC,MAAa,qBAAsB,SAAQ,iBAAW;CAIrD;AAJD,sDAIC;AAED,MAAa,sBAAuB,SAAQ,iBAAW;CAMtD;AAND,wDAMC;AAED,MAAa,gBAAiB,SAAQ,iBAAW;CAuBhD;AAvBD,4CAuBC;AApBA;IADC,iBAAW;6CACA;AAKZ;IADC,iBAAW;8DACiB;AAa7B;IADC,IAAA,cAAQ,EAAC,sBAAsB,CAAC;0DACU;AAI5C,MAAa,oBAAqB,SAAQ,iBAAW;CASpD;AATD,oDASC;AANA;IADC,iBAAW;iDACA;AAQb,MAAa,iBAAkB,SAAQ,iBAAW;CAOjD;AAPD,8CAOC;AAJA;IADC,iBAAW;8CACA;AAMb,MAAa,eAAgB,SAAQ,iBAAW;CAiB/C;AAjBD,0CAiBC;AAfA;IADC,iBAAW;4CACA;AAIZ;IADC,iBAAW;kDACM;AAElB;IADC,iBAAW;kEACsB;AAOlC;IADC,iBAAW;6DACiB;AAI9B,MAAa,QAAS,SAAQ,iBAAW;CA0BxC;AA1BD,4BA0BC;AAxBA;IADC,iBAAW;qCACA;AAEZ;IADC,iBAAW;sDACyB;AAErC;IADC,iBAAW;oDACuB;AAkBnC;IADC,iBAAW;wCACG;AAIhB,MAAa,gBAAiB,SAAQ,iBAAW;CAwChD;AAxCD,4CAwCC;AAtCA;IADC,iBAAW;6CACA;AAEZ;IADC,iBAAW;4DACe;AAM3B;IADC,iBAAW;qDACQ;AAgCrB,MAAa,QAAS,SAAQ,iBAAW;CAYxC;AAZD,4BAYC;AAVA;IADC,iBAAW;qCACA;AAEZ;IADC,iBAAW;oDACe;AAE3B;IADC,iBAAW;0CACK;AAQlB,MAAa,YAAa,SAAQ,iBAAW;CAM5C;AAND,oCAMC;AADA;IADC,iBAAW;6CACI;AAGjB,MAAa,yBAA0B,SAAQ,iBAAW;CAezD;AAfD,8DAeC;AAVA;IADC,iBAAW;yDACG;AAGf;IADC,iBAAW;2DACK;AAGjB;IADC,iBAAW;4DACM;AAGlB;IADC,iBAAW;4DACM"}

package/dist/operate/lib/TestableOperateApiClient.d.ts

@@ -0,0 +1,7 @@
+import { ClientConstructor } from '../../lib';
+import { OperateApiClient } from './OperateApiClient';
+import { Query } from './OperateDto';
+export declare class TestableOperateApiClient extends OperateApiClient {
+    constructor(options?: ClientConstructor);
+    addTenantIdToFilter<T extends Query<any>>(query: T, tenantId?: string): Query<any>;
+}

package/dist/operate/lib/TestableOperateApiClient.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestableOperateApiClient = void 0;
+const OperateApiClient_1 = require("./OperateApiClient");
+class TestableOperateApiClient extends OperateApiClient_1.OperateApiClient {
+    constructor(options) {
+        super(options);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    addTenantIdToFilter(query, tenantId) {
+        return super.addTenantIdToFilter(query, tenantId);
+    }
+}
+exports.TestableOperateApiClient = TestableOperateApiClient;
+//# sourceMappingURL=TestableOperateApiClient.js.map

package/dist/operate/lib/TestableOperateApiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestableOperateApiClient.js","sourceRoot":"","sources":["../../../src/operate/lib/TestableOperateApiClient.ts"],"names":[],"mappings":";;;AAEA,yDAAqD;AAGrD,MAAa,wBAAyB,SAAQ,mCAAgB;IAC7D,YAAY,OAA2B;QACtC,KAAK,CAAC,OAAO,CAAC,CAAA;IACf,CAAC;IAED,8DAA8D;IAC9C,mBAAmB,CAClC,KAAQ,EACR,QAAiB;QAEjB,OAAO,KAAK,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;IAClD,CAAC;CACD;AAZD,4DAYC"}

package/dist/operate/lib/parseSearchResults.d.ts

@@ -0,0 +1,4 @@
+import { SearchResults } from './OperateDto';
+export declare function parseSearchResults<T>(json: string, dto: {
+    new (...args: any[]): T;
+}): SearchResults<T>;

package/dist/operate/lib/parseSearchResults.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSearchResults = void 0;
+const lossless_json_1 = require("lossless-json");
+const lib_1 = require("../../lib");
+function parseSearchResults(json, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+dto) {
+    const parsedResult = (0, lossless_json_1.parse)(json);
+    // Assuming `parsedResult` matches the structure of `SearchResults<T>`
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const items = parsedResult.items.map((item) => (0, lib_1.losslessParse)((0, lossless_json_1.stringify)(item), dto));
+    // Apply additional parsing or annotations if necessary
+    // For each item in the array, you could potentially apply the same or similar logic
+    // as in `losslessParse` if your items have properties that need special handling.
+    const total = parsedResult.total.toString(); // Or convert based on your needs
+    // Construct the final object, assuming `SearchResults` is a simple interface without methods
+    const result = {
+        items: items,
+        sortValues: parsedResult.sortValues, // Handle according to your needs
+        total,
+    };
+    return result;
+}
+exports.parseSearchResults = parseSearchResults;
+//# sourceMappingURL=parseSearchResults.js.map

package/dist/operate/lib/parseSearchResults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSearchResults.js","sourceRoot":"","sources":["../../../src/operate/lib/parseSearchResults.ts"],"names":[],"mappings":";;;AAAA,iDAAgD;AAEhD,mCAAyC;AAIzC,SAAgB,kBAAkB,CACjC,IAAY;AACZ,8DAA8D;AAC9D,GAAgC;IAEhC,MAAM,YAAY,GAAG,IAAA,qBAAK,EAAC,IAAI,CAAqB,CAAA;IAEpD,sEAAsE;IACtE,8DAA8D;IAC9D,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAClD,IAAA,mBAAa,EAAC,IAAA,yBAAS,EAAC,IAAI,CAAW,EAAE,GAAG,CAAC,CAC7C,CAAA;IAED,uDAAuD;IACvD,oFAAoF;IACpF,kFAAkF;IAElF,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAA,CAAC,iCAAiC;IAE7E,6FAA6F;IAC7F,MAAM,MAAM,GAAqB;QAChC,KAAK,EAAE,KAAY;QACnB,UAAU,EAAE,YAAY,CAAC,UAAU,EAAE,iCAAiC;QACtE,KAAK;KACL,CAAA;IAED,OAAO,MAAM,CAAA;AACd,CAAC;AA3BD,gDA2BC"}

package/dist/optimize/index.d.ts

@@ -0,0 +1,2 @@
+export { OptimizeApiClient } from './lib/OptimizeApiClient';
+export * as OptimizeDto from './lib/APIObjects';

package/dist/optimize/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeDto = exports.OptimizeApiClient = void 0;
+var OptimizeApiClient_1 = require("./lib/OptimizeApiClient");
+Object.defineProperty(exports, "OptimizeApiClient", { enumerable: true, get: function () { return OptimizeApiClient_1.OptimizeApiClient; } });
+exports.OptimizeDto = __importStar(require("./lib/APIObjects"));
+//# sourceMappingURL=index.js.map

package/dist/optimize/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/optimize/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6DAA2D;AAAlD,sHAAA,iBAAiB,OAAA;AAE1B,gEAA+C"}

package/dist/optimize/lib/APIObjects.d.ts

@@ -0,0 +1,191 @@
+export type DashboardCollection = Array<{
+    id: string;
+}>;
+export type ReportCollection = Array<{
+    id: string;
+}>;
+export type SingleProcessReport = unknown;
+export interface DashboardDefinition {
+    id: string;
+    exportEntityType: 'dashboard';
+    name: string;
+    sourceIndexVersion: number;
+    collectionId: null | string;
+    reports: Array<{
+        id: string;
+    }>;
+    availableFilters: Array<unknown>;
+}
+export interface ReportDataPage {
+    searchRequestId: string;
+    numberOfRecordsInResponse: number;
+    totalNumberOfRecords: number;
+    reportId: string;
+    data: ReportData[];
+}
+export interface ReportData {
+    processDefinitionKey: string;
+    processDefinitionId: string;
+    processInstanceId: string;
+    businessKey: string;
+    startDate: string;
+    endDate: string;
+    duration: number;
+    engineName: string;
+    tenantId: null;
+    variables: unknown;
+}
+export interface ReportDataExporter {
+    next: () => Promise<ReportDataPage>;
+}
+/**
+ * The object interface for CloudEvents 1.0.
+ * @see https://github.com/cloudevents/spec/blob/v1.0/spec.md
+ */
+export interface CloudEventV1<T> extends CloudEventV1Attributes<T> {
+    /**
+     * [REQUIRED] Identifies the event. Producers MUST ensure that `source` + `id`
+     * is unique for each distinct event. If a duplicate event is re-sent (e.g. due
+     * to a network error) it MAY have the same `id`. Consumers MAY assume that
+     * Events with identical `source` and `id` are duplicates.
+     * @required Non-empty string. Unique within producer.
+     * @example An event counter maintained by the producer
+     * @example A UUID
+     */
+    id: string;
+    /**
+     * [REQUIRED] The version of the CloudEvents specification which the event
+     * uses. This enables the interpretation of the context. Compliant event
+     * producers MUST use a value of `1.0` when referring to this version of the
+     * specification.
+     * @required MUST be a non-empty string.
+     */
+    specversion: string;
+}
+export interface CloudEventV1Attributes<T> extends CloudEventV1OptionalAttributes<T> {
+    /**
+     * [REQUIRED] Identifies the context in which an event happened. Often this
+     * will include information such as the type of the event source, the
+     * organization publishing the event or the process that produced the event. The
+     * exact syntax and semantics behind the data encoded in the URI is defined by
+     * the event producer.
+     * Producers MUST ensure that `source` + `id` is unique for each distinct event.
+     * An application MAY assign a unique `source` to each distinct producer, which
+     * makes it easy to produce unique IDs since no other producer will have the same
+     * source. The application MAY use UUIDs, URNs, DNS authorities or an
+     * application-specific scheme to create unique `source` identifiers.
+     * A source MAY include more than one producer. In that case the producers MUST
+     * collaborate to ensure that `source` + `id` is unique for each distinct event.
+     * @required Non-empty URI-reference
+     */
+    source: string;
+    /**
+     * [REQUIRED] This attribute contains a value describing the type of event
+     * related to the originating occurrence. Often this attribute is used for
+     * routing, observability, policy enforcement, etc. The format of this is
+     * producer defined and might include information such as the version of the
+     * `type` - see
+     * [Versioning of Attributes in the Primer](primer.md#versioning-of-attributes)
+     * for more information.
+     * @required MUST be a non-empty string
+     * @should SHOULD be prefixed with a reverse-DNS name. The prefixed domain dictates the
+     *   organization which defines the semantics of this event type.
+     * @example com.github.pull.create
+     * @example com.example.object.delete.v2
+     */
+    type: string;
+}
+export interface CloudEventV1OptionalAttributes<T> {
+    /**
+     * The following fields are optional.
+     */
+    /**
+     * [OPTIONAL] Content type of `data` value. This attribute enables `data` to
+     * carry any type of content, whereby format and encoding might differ from that
+     * of the chosen event format. For example, an event rendered using the
+     * [JSON envelope](./json-format.md#3-envelope) format might carry an XML payload
+     * in `data`, and the consumer is informed by this attribute being set to
+     * "application/xml". The rules for how `data` content is rendered for different
+     * `datacontenttype` values are defined in the event format specifications; for
+     * example, the JSON event format defines the relationship in
+     * [section 3.1](./json-format.md#31-handling-of-data).
+     */
+    datacontenttype?: string;
+    /**
+     * [OPTIONAL] Identifies the schema that `data` adheres to. Incompatible
+     * changes to the schema SHOULD be reflected by a different URI. See
+     * [Versioning of Attributes in the Primer](primer.md#versioning-of-attributes)
+     * for more information.
+     * If present, MUST be a non-empty URI.
+     */
+    dataschema?: string;
+    /**
+     * [OPTIONAL] This describes the subject of the event in the context of the
+     * event producer (identified by `source`). In publish-subscribe scenarios, a
+     * subscriber will typically subscribe to events emitted by a `source`, but the
+     * `source` identifier alone might not be sufficient as a qualifier for any
+     * specific event if the `source` context has internal sub-structure.
+     *
+     * Identifying the subject of the event in context metadata (opposed to only in
+     * the `data` payload) is particularly helpful in generic subscription filtering
+     * scenarios where middleware is unable to interpret the `data` content. In the
+     * above example, the subscriber might only be interested in blobs with names
+     * ending with '.jpg' or '.jpeg' and the `subject` attribute allows for
+     * constructing a simple and efficient string-suffix filter for that subset of
+     * events.
+     *
+     * If present, MUST be a non-empty string.
+     * @example "https://example.com/storage/tenant/container"
+     * @example "mynewfile.jpg"
+     */
+    subject?: string;
+    /**
+     * [OPTIONAL] Timestamp of when the occurrence happened. If the time of the
+     * occurrence cannot be determined then this attribute MAY be set to some other
+     * time (such as the current time) by the CloudEvents producer, however all
+     * producers for the same `source` MUST be consistent in this respect. In other
+     * words, either they all use the actual time of the occurrence or they all use
+     * the same algorithm to determine the value used.
+     * @example "2020-08-08T14:48:09.769Z"
+     */
+    time?: string;
+    /**
+     * [OPTIONAL] The event payload. This specification does not place any restriction
+     * on the type of this information. It is encoded into a media format which is
+     * specified by the datacontenttype attribute (e.g. application/json), and adheres
+     * to the dataschema format when those respective attributes are present.
+     */
+    data?: T;
+    /**
+     * [OPTIONAL] The event payload encoded as base64 data. This is used when the
+     * data is in binary form.
+     * @see https://github.com/cloudevents/spec/blob/v1.0/json-format.md#31-handling-of-data
+     */
+    data_base64?: string;
+    /**
+     * [OPTIONAL] CloudEvents extension attributes.
+     */
+    [key: string]: unknown;
+}
+export type VariableType = 'string' | 'short' | 'long' | 'double' | 'integer' | 'boolean' | 'date';
+export interface Variable {
+    id: string;
+    name: string;
+    type: VariableType;
+    value: string;
+    processInstanceId: string;
+    processDefinitionKey: string;
+}
+export type EntityImportResponse = Array<{
+    id: string;
+    entityType: 'dashboard' | 'report';
+}>;
+export interface VariableLabel {
+    variableName: string;
+    variableType: VariableType;
+    variableLabel: string;
+}
+export interface VariableLabels {
+    definitionKey: string;
+    labels: VariableLabel[];
+}

package/dist/optimize/lib/APIObjects.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=APIObjects.js.map

package/dist/optimize/lib/APIObjects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"APIObjects.js","sourceRoot":"","sources":["../../../src/optimize/lib/APIObjects.ts"],"names":[],"mappings":""}