@progress/sitefinity-webservices-sdk 1.1.16 → 2.0.0

package/sitefinity-webservices-sdk.js

@@ -0,0 +1,2764 @@
+/*! @progress/sitefinity-webservices-sdk v2.0.0 | MIT */
+var Sitefinity = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // sitefinity-webservices-sdk.ts
+  var sitefinity_webservices_sdk_exports = {};
+  __export(sitefinity_webservices_sdk_exports, {
+    BatchRequest: () => BatchRequest,
+    BinaryExpression: () => BinaryExpression,
+    BlobBuilder: () => BlobBuilder,
+    CONTENT_TYPES: () => CONTENT_TYPES,
+    ChunkUploadSdk: () => ChunkUploadSdk,
+    ChunkedFileUploadUtilities: () => ChunkedFileUploadUtilities,
+    CommitChunksRequest: () => CommitChunksRequest,
+    ComplexExpression: () => ComplexExpression,
+    CreateRelatedRequest: () => CreateRelatedRequest,
+    CreateRequest: () => CreateRequest,
+    Data: () => Data,
+    DeleteRelatedByIdRequest: () => DeleteRelatedByIdRequest,
+    DeleteRelatedRequest: () => DeleteRelatedRequest,
+    DeleteRequest: () => DeleteRequest,
+    EXPRESSION_TYPE: () => EXPRESSION_TYPE,
+    ExecutableRequest: () => ExecutableRequest,
+    ExpressionBase: () => ExpressionBase,
+    FetchTransport: () => FetchTransport,
+    GetByIdRequest: () => GetByIdRequest,
+    GetRelatedByIdRequest: () => GetRelatedByIdRequest,
+    GetRelatedRequest: () => GetRelatedRequest,
+    GetRequest: () => GetRequest,
+    HEADER_NAMES: () => HEADER_NAMES,
+    HTTP_METHODS: () => HTTP_METHODS,
+    ODATA_PARAMS: () => ODATA_PARAMS,
+    OrderProperty: () => OrderProperty,
+    Query: () => Query,
+    QueryBase: () => QueryBase,
+    QueryBuilder: () => QueryBuilder,
+    RequestBase: () => RequestBase,
+    RequestFactory: () => RequestFactory,
+    SF_PARAMS: () => SF_PARAMS,
+    Sitefinity: () => Sitefinity,
+    Transaction: () => Transaction,
+    UpdateRequest: () => UpdateRequest,
+    UploadChunkRequest: () => UploadChunkRequest,
+    UploadRequest: () => UploadRequest,
+    WhereQuery: () => WhereQuery,
+    XhrTransport: () => XhrTransport,
+    utils: () => utils
+  });
+
+  // src/BlobBuilder.ts
+  var BlobBuilder = class {
+    constructor() {
+      this.blob = new Blob();
+    }
+    /** Appends a value to the blob being built. */
+    append(value) {
+      this.blob = new Blob([this.blob, value]);
+    }
+    /** Returns the accumulated blob content. */
+    build() {
+      return this.blob;
+    }
+  };
+
+  // src/constants.ts
+  var EXPRESSION_TYPE = {
+    query: 1,
+    where: 100,
+    and: "and",
+    or: "or",
+    not: "not",
+    eq: "eq",
+    ne: "ne",
+    lt: "lt",
+    le: "le",
+    gt: "gt",
+    ge: "ge",
+    any: "any",
+    in: "in",
+    contains: "contains",
+    startsWith: "startsWith",
+    endsWith: "endsWith"
+  };
+  var ODATA_PARAMS = {
+    $filter: "$filter",
+    $select: "$select",
+    $expand: "$expand",
+    $orderby: "$orderby",
+    $skip: "$skip",
+    $top: "$top",
+    $count: "$count",
+    $search: "$search"
+  };
+  var SF_PARAMS = {
+    provider: "sf_provider",
+    culture: "sf_culture",
+    siteId: "sf_site",
+    fallbackParams: "sf_fallback_prop_names",
+    parentId: "parentId"
+  };
+  var HEADER_NAMES = {
+    contentType: "Content-Type",
+    authorization: "Authorization",
+    contentEncoding: "Content-Encoding",
+    operation: "X-Operation",
+    properties: "X-Sf-Properties",
+    fileName: "X-File-Name",
+    serviceRequest: "X-SF-Service-Request",
+    choicesBinaryRepresentation: "X-SF-Binary-Choice-Representation",
+    integrationMode: "X-SF-Integration-Mode",
+    chunkOrdinal: "X-SF-Chunk-Ordinal",
+    chunkSize: "X-SF-Chunk-Size",
+    fileSize: "X-SF-File-Size",
+    chunkedFileUploadSessionId: "X-SF-Chunked-File-Upload-Session-Id",
+    blobStorageProviderName: "X-SF-Blob-Storage-Provider-Name"
+  };
+  var HTTP_METHODS = {
+    get: "GET",
+    put: "PUT",
+    post: "POST",
+    patch: "PATCH",
+    delete: "DELETE"
+  };
+  var CONTENT_TYPES = {
+    json: "application/json"
+  };
+
+  // src/utils.ts
+  var utils = class _utils {
+    /**
+     * Determines whether a value is a primitive or boxed string.
+     *
+     * @param obj Value to inspect.
+     * @returns `true` when the value is a string.
+     */
+    static isString(obj) {
+      return typeof obj === "string" || obj instanceof String;
+    }
+    /**
+     * Determines whether a value is a boolean.
+     *
+     * @param obj Value to inspect.
+     * @returns `true` for primitive boolean values.
+     */
+    static isBoolean(obj) {
+      return typeof obj === "boolean";
+    }
+    /**
+     * Determines whether a value is a {@link Blob}.
+     *
+     * @param obj Value to inspect.
+     * @returns `true` when the value is a `Blob`.
+     */
+    static isBlob(obj) {
+      return obj instanceof Blob;
+    }
+    /**
+     * Determines whether a value is a finite number.
+     *
+     * @param value Value to inspect.
+     * @returns `true` for finite numeric values.
+     */
+    static isNumber(value) {
+      return typeof value === "number" && isFinite(value);
+    }
+    /**
+     * Determines whether a value is callable.
+     *
+     * @param func Value to inspect.
+     * @returns `true` when the value is a function.
+     */
+    static isFunction(func) {
+      return typeof func === "function";
+    }
+    /**
+     * Converts request data to its wire representation.
+     *
+     * Strings and blobs are returned unchanged. Other values are serialized with `JSON.stringify`.
+     *
+     * @param data Request body value.
+     * @returns The original string or blob, or a JSON string for other values.
+     */
+    static serializeToJSON(data) {
+      if (!_utils.isString(data) && !this.isBlob(data)) {
+        return JSON.stringify(data);
+      }
+      return data;
+    }
+    /**
+     * Parses a response string as a number or JSON value.
+     *
+     * ISO 8601 date strings in parsed objects and arrays are converted to {@link Date} instances.
+     * Non-JSON text returns `null`.
+     *
+     * @param data Response text to parse.
+     * @returns The parsed value, or `null` when the input is empty or not valid JSON.
+     */
+    static parseStringToJson(data) {
+      if (!data) {
+        return null;
+      }
+      const number = Number(data);
+      if (!isNaN(number)) {
+        return number;
+      }
+      let result = null;
+      try {
+        result = JSON.parse(data);
+        result = _utils._parseDateProperties(result);
+      } catch (e) {
+      }
+      return result;
+    }
+    /**
+     * Converts top-level {@link Date} properties to ISO 8601 strings in place.
+     *
+     * @param data Object that will be sent in a request.
+     * @returns The same object instance after conversion.
+     */
+    static convertDateFieldToISOString(data) {
+      for (const obj in data) {
+        if (data[obj] instanceof Date) {
+          data[obj] = data[obj].toISOString();
+        }
+      }
+      return data;
+    }
+    /**
+     * Generates a four-character hexadecimal segment.
+     *
+     * @returns A pseudo-random lowercase hexadecimal string.
+     */
+    static hex16() {
+      return Math.floor((1 + Math.random()) * 65536).toString(16).substr(1);
+    }
+    /**
+     * Ensures that a URL ends with exactly one slash.
+     *
+     * @param url URL to normalize.
+     * @returns The normalized URL.
+     */
+    static addTrailingSlash(url) {
+      url = _utils.removeSlashes(url);
+      url += "/";
+      return url;
+    }
+    /**
+     * Removes one trailing slash from a URL.
+     *
+     * @param url URL to normalize.
+     * @returns The URL without a trailing slash.
+     */
+    static removeSlashes(url) {
+      let ret = url;
+      const lastChar = ret.substr(-1);
+      if (lastChar == "/")
+        ret = ret.substr(0, ret.length - 1);
+      return ret;
+    }
+    /**
+     * Performs the SDK's backward-compatible shallow clone operation.
+     *
+     * The optional action is called while properties are copied and is used by fluent query
+     * objects to update the cloned instance.
+     *
+     * @param from Source object.
+     * @param to Optional target object.
+     * @param action Optional callback invoked with the target during copying.
+     * @returns The populated target object.
+     */
+    static clone(from, to = {}, action = null) {
+      if (!to)
+        to = {};
+      for (const property in from) {
+        if (from[property] && from[property].constructor && from[property].constructor === Object && typeof from[property] == "function") {
+          to[property] = to[property] || {};
+          arguments.callee(to[property], from[property]);
+        } else {
+          to[property] = from[property];
+        }
+        if (typeof action === "function")
+          action(to);
+      }
+      return to;
+    }
+    static _parseDateProperties(data) {
+      for (const obj in data) {
+        if (data[obj] instanceof Array || data[obj] instanceof Object && !(data[obj] instanceof Function))
+          this._parseDateProperties(data[obj]);
+        else
+          data[obj] = _utils._tryFormatFieldToDate(data[obj]);
+      }
+      return data;
+    }
+    static _tryFormatFieldToDate(date) {
+      if (/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/.test(date)) {
+        date = new Date(date);
+      }
+      return date;
+    }
+  };
+
+  // src/Expression.ts
+  var ExpressionBase = class {
+    /** Creates an expression node with the specified operator or logical type. */
+    constructor(type) {
+      this.type = type;
+    }
+    /** Returns this expression's operator or logical type. */
+    getType() {
+      return this.type;
+    }
+  };
+  var BinaryExpression = class extends ExpressionBase {
+    /**
+     * Creates a comparison expression.
+     *
+     * @param type Supported comparison operator, such as `eq`, `ne`, or `contains`.
+     * @param parameter Property being tested.
+     * @param constant Value compared with the property.
+     * @param caseSensitive Whether string functions should preserve case.
+     */
+    constructor(type, parameter, constant, caseSensitive = true) {
+      super(type);
+      this.parameter = parameter;
+      this.constant = constant;
+      this.caseSensitive = caseSensitive;
+    }
+    /** Returns the property being compared. */
+    getParameter() {
+      return this.parameter;
+    }
+    /** Returns the comparison value. */
+    getConstant() {
+      return this.constant;
+    }
+    /** Returns whether string matching preserves case. */
+    isCaseSensitive() {
+      return this.caseSensitive;
+    }
+  };
+  var ComplexExpression = class extends ExpressionBase {
+    /** Creates a logical expression containing the supplied child nodes. */
+    constructor(type, expressions) {
+      super(type);
+      this.expressions = expressions;
+    }
+    /** Returns the child expressions in their current order. */
+    getExpressions() {
+      return this.expressions;
+    }
+  };
+
+  // src/WhereQuery.ts
+  var WhereQuery = class _WhereQuery {
+    /** Creates a logical group attached to the supplied parent. */
+    constructor(parent, type = EXPRESSION_TYPE.and) {
+      this.parent = parent;
+      this.expression = new ComplexExpression(type, []);
+    }
+    /**
+     * Starts a nested `and` group.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    and() {
+      return new _WhereQuery(this, EXPRESSION_TYPE.and);
+    }
+    /**
+     * Starts a nested `or` group.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    or() {
+      return new _WhereQuery(this, EXPRESSION_TYPE.or);
+    }
+    /**
+     * Starts an OData `any` group for collection-valued properties.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    any() {
+      return new _WhereQuery(this, EXPRESSION_TYPE.any);
+    }
+    /**
+     * Starts a negated group.
+     * @returns A nested builder whose `done()` returns this group.
+     * @throws Error If more than one direct condition is added to the group.
+     */
+    not() {
+      return new _WhereQuery(this, EXPRESSION_TYPE.not);
+    }
+    /**
+     * Adds an equality condition.
+     * @param parameter Property name.
+     * @param constant Value to compare with.
+     * @returns This filter builder.
+     */
+    eq(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.eq, parameter, constant);
+    }
+    /**
+     * Adds an inequality condition.
+     * @param parameter Property name.
+     * @param constant Value to compare with.
+     * @returns This filter builder.
+     */
+    ne(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.ne, parameter, constant);
+    }
+    /** Adds a greater-than condition for number, string, or date values. */
+    gt(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.gt, parameter, constant);
+    }
+    /** Adds a greater-than-or-equal condition for number, string, or date values. */
+    gte(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.ge, parameter, constant);
+    }
+    /** Adds a less-than condition for number, string, or date values. */
+    lt(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.lt, parameter, constant);
+    }
+    /** Adds a less-than-or-equal condition for number, string, or date values. */
+    lte(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.le, parameter, constant);
+    }
+    /** Adds a string-prefix condition, optionally using case-insensitive matching. */
+    startsWith(parameter, constant, caseSensitive = true) {
+      return this.simple(EXPRESSION_TYPE.startsWith, parameter, constant, caseSensitive);
+    }
+    /** Adds a string-contains condition, optionally using case-insensitive matching. */
+    contains(parameter, constant, caseSensitive = true) {
+      return this.simple(EXPRESSION_TYPE.contains, parameter, constant, caseSensitive);
+    }
+    /** Adds a string-suffix condition, optionally using case-insensitive matching. */
+    endsWith(parameter, constant, caseSensitive = true) {
+      return this.simple(EXPRESSION_TYPE.endsWith, parameter, constant, caseSensitive);
+    }
+    /**
+     * Adds an OData `in` condition.
+     *
+     * The constant must be an array; otherwise `build()` throws an error.
+     */
+    in(parameter, constant) {
+      return this.simple(EXPRESSION_TYPE.in, parameter, constant);
+    }
+    /**
+     * Completes this group and returns its parent.
+     *
+     * Call once for the root filter to return to `Query`, and once for each
+     * nested group to continue the surrounding chain.
+     *
+     * @returns The parent query or enclosing filter group.
+     */
+    done() {
+      if (this.parent instanceof _WhereQuery) {
+        this.parent.addComplexExpression(this);
+        if (this.expression.getType() === EXPRESSION_TYPE.not)
+          return this.parent;
+      }
+      return this.parent;
+    }
+    /** Returns the expression tree represented by this filter group. */
+    getExpression() {
+      return this.expression;
+    }
+    simple(type, parameter, constant, caseSensitive = true) {
+      const currentExpr = new BinaryExpression(type, parameter, constant, caseSensitive);
+      const subExpressions = this.expression.getExpressions();
+      subExpressions.push(currentExpr);
+      if (this.expression.getType() === EXPRESSION_TYPE.not && subExpressions.length > 1)
+        throw new Error("Invalid operators count!");
+      return this;
+    }
+    addComplexExpression(subQuery) {
+      const subExpression = subQuery.getExpression();
+      this.expression.getExpressions().push(subExpression);
+    }
+  };
+
+  // src/Requests/RequestBase.ts
+  var RequestBase = class {
+    /**
+     * Creates a low-level request from its URL, query, callback, and entity options.
+     *
+     * @param options Request options used to build and execute the request.
+     */
+    constructor(options) {
+      this.successCb = options.successCb;
+      this.failureCb = options.failureCb;
+      this.progressCb = options.progressCb;
+      this.urlOptions = options.urlOptions;
+      this.key = options.key;
+      this.action = options.action;
+      this.fallbackProperties = options.fallbackProperties;
+      this.query = options.query;
+    }
+    /**
+     * Builds the encoded OData and Sitefinity query string for the request.
+     *
+     * @param urlOptions URL options whose provider, culture, site, and extra parameters are included.
+     * @param query OData query options to include.
+     * @returns A query string beginning with `?`, or `null` when no parameters apply.
+     */
+    getQueryString(urlOptions, query) {
+      const paramDictionary = {};
+      this.getQueryParameters(paramDictionary, urlOptions, query);
+      const keys = Object.keys(paramDictionary);
+      if (keys.length == 0)
+        return null;
+      let queryString = "?";
+      for (const prop in paramDictionary) {
+        queryString += prop + "=" + paramDictionary[prop] + "&";
+      }
+      queryString = queryString.substring(0, queryString.length - 1);
+      return queryString;
+    }
+    /** Returns the request body. Subclasses override this for requests with content. */
+    getBody() {
+      return void 0;
+    }
+    /** Returns the HTTP method used by the request. */
+    getMethod() {
+      return null;
+    }
+    /** Returns the headers used by the request, including a JSON content type by default. */
+    getHeaders() {
+      const headers = this.urlOptions.additionalHeaders ?? {};
+      if (headers[HEADER_NAMES.contentType] == void 0) {
+        headers[HEADER_NAMES.contentType] = CONTENT_TYPES.json;
+      }
+      return headers;
+    }
+    /** Builds the request URL, including the entity key, action, count path, and query string. */
+    buildUrl() {
+      let url = this.urlOptions.baseUrl + (this.urlOptions.entitySet || "");
+      url += this.key !== void 0 && this.key !== null ? "(" + this.key + ")" : "";
+      if (this.action) {
+        url += url.endsWith("/") ? "" : "/";
+        url += this.action;
+      }
+      if (this.query) {
+        const getCount = this.query.build().$count;
+        if (utils.isBoolean(getCount) && !getCount) {
+          url += "/$count";
+        }
+      }
+      return this.addQueryParameters(url);
+    }
+    parseResponse(response) {
+      const data = utils.parseStringToJson(response.body);
+      if (data) {
+        if (response.status >= 400 && data.error) {
+          return data.error;
+        }
+        return data;
+      }
+      return response.body;
+    }
+    addQueryParameters(url) {
+      let queryString = this.getQueryString(this.urlOptions, this.query);
+      if (queryString) {
+        if (url.indexOf("?") > -1 && queryString[0] == "?") {
+          queryString = "&" + queryString.substring(1);
+        }
+        url += queryString;
+      }
+      return url;
+    }
+    getQueryParameters(paramDictionary, urlOptions, query) {
+      if (query) {
+        const builtQuery = query.build();
+        if (utils.isString(builtQuery.$filter))
+          paramDictionary[ODATA_PARAMS.$filter] = builtQuery.$filter;
+        if (utils.isString(builtQuery.$select))
+          paramDictionary[ODATA_PARAMS.$select] = builtQuery.$select;
+        if (utils.isString(builtQuery.$expand))
+          paramDictionary[ODATA_PARAMS.$expand] = builtQuery.$expand;
+        if (utils.isString(builtQuery.$orderby))
+          paramDictionary[ODATA_PARAMS.$orderby] = builtQuery.$orderby;
+        if (utils.isNumber(builtQuery.$skip))
+          paramDictionary[ODATA_PARAMS.$skip] = builtQuery.$skip;
+        if (utils.isNumber(builtQuery.$top))
+          paramDictionary[ODATA_PARAMS.$top] = builtQuery.$top;
+        if (utils.isString(builtQuery.$search))
+          paramDictionary[ODATA_PARAMS.$search] = builtQuery.$search;
+        if (utils.isBoolean(builtQuery.$count) && builtQuery.$count)
+          paramDictionary[ODATA_PARAMS.$count] = builtQuery.$count;
+      }
+      if (urlOptions.provider) {
+        paramDictionary[SF_PARAMS.provider] = urlOptions.provider;
+      }
+      if (urlOptions.culture) {
+        paramDictionary[SF_PARAMS.culture] = urlOptions.culture;
+      }
+      if (urlOptions.siteId) {
+        paramDictionary[SF_PARAMS.siteId] = urlOptions.siteId;
+      }
+      if (this.fallbackProperties) {
+        paramDictionary[SF_PARAMS.fallbackParams] = this.fallbackProperties.join();
+      }
+      if (urlOptions.additionalQueryParams) {
+        for (const key in urlOptions.additionalQueryParams) {
+          if (urlOptions.additionalQueryParams.hasOwnProperty(key)) {
+            paramDictionary[key] = urlOptions.additionalQueryParams[key];
+          }
+        }
+      }
+    }
+  };
+
+  // src/Transport/XhrTransport.ts
+  var XMLHttpRequestDone = 4;
+  var XhrTransport = class {
+    /** Sends the request with a new `XMLHttpRequest` and reports its final state. */
+    send(request, onComplete) {
+      const xhr = new XMLHttpRequest();
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === XMLHttpRequestDone) {
+          onComplete({
+            status: xhr.status,
+            body: xhr.responseText,
+            // Parsed on demand: only $batch reads the headers, and minimal XHR fakes may not implement them.
+            get headers() {
+              return parseResponseHeaders(xhr.getAllResponseHeaders());
+            }
+          });
+        }
+      };
+      if (request.onUploadProgress && xhr.upload) {
+        xhr.upload.onprogress = request.onUploadProgress;
+      }
+      xhr.open(request.method, request.url, true);
+      for (const name of Object.keys(request.headers)) {
+        xhr.setRequestHeader(name, request.headers[name]);
+      }
+      xhr.send(request.body);
+    }
+  };
+  function parseResponseHeaders(raw) {
+    const headers = {};
+    for (const line of (raw ?? "").split(/\r?\n/)) {
+      const separator = line.indexOf(":");
+      if (separator > 0) {
+        headers[line.substring(0, separator).trim().toLowerCase()] = line.substring(separator + 1).trim();
+      }
+    }
+    return headers;
+  }
+
+  // src/Requests/ExecutableRequest.ts
+  var defaultTransport = new XhrTransport();
+  var ExecutableRequest = class extends RequestBase {
+    /**
+     * Creates an executable request with authentication and SDK-wide execution options.
+     *
+     * @param requestOptions Request URL, query, data, and callback options.
+     * @param token Optional bearer token or legacy authorization header value.
+     * @param sdkOptions SDK-wide handlers and request behavior options.
+     */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions);
+      this.token = token;
+      this.successCb = this.successCb || sdkOptions.handlers?.successCb;
+      this.failureCb = this.failureCb || sdkOptions.handlers?.failureCb;
+      this.enableUnlimitedChoices = sdkOptions.enableUnlimitedChoices;
+      this.integrationMode = sdkOptions.integrationMode;
+      this.transport = sdkOptions.transport ?? defaultTransport;
+    }
+    /**
+     * Sends the request asynchronously.
+     *
+     * Successful responses are passed to `successCb`; HTTP errors are normalized and passed to
+     * `failureCb`. The method returns immediately and does not return a promise or response value.
+     */
+    execute() {
+      this.transport.send(
+        {
+          method: this.getMethod(),
+          url: this.buildUrl(),
+          headers: this.buildHeaders(),
+          body: utils.serializeToJSON(this.getBody()),
+          onUploadProgress: utils.isFunction(this.progressCb) ? (event) => this.progressCb(this.getProgressPayload(event)) : void 0
+        },
+        (response) => this.handleResponse(response)
+      );
+    }
+    /** Maps the transport's upload progress event to the value passed to `progressCb`. */
+    getProgressPayload(event) {
+      return event;
+    }
+    handleResponse(response) {
+      if (response.status > 0) {
+        let data = this.parseResponse(response);
+        if (response.status >= 200 && response.status <= 206) {
+          if (this.successCb && utils.isFunction(this.successCb)) {
+            this.successCb(data);
+          }
+        } else if (response.status >= 400) {
+          if (utils.isString(data)) {
+            data = {
+              message: data
+            };
+          }
+          data.status = response.status;
+          if (this.failureCb && utils.isFunction(this.failureCb)) {
+            this.failureCb(data);
+          }
+        }
+      }
+    }
+    buildHeaders() {
+      const headers = { ...this.getHeaders() };
+      if (this.token) {
+        if (typeof this.token === "string") {
+          headers[HEADER_NAMES.authorization] = this.token;
+        } else {
+          headers[HEADER_NAMES.authorization] = this.token.type + " " + this.token.value;
+        }
+      }
+      if (this.enableUnlimitedChoices) {
+        headers[HEADER_NAMES.choicesBinaryRepresentation] = "true";
+      }
+      if (this.integrationMode) {
+        headers[HEADER_NAMES.integrationMode] = "true";
+      }
+      headers[HEADER_NAMES.serviceRequest] = "true";
+      return headers;
+    }
+  };
+
+  // src/Requests/Request.ts
+  var GetRequest = class extends ExecutableRequest {
+    /** Creates a collection GET request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+    }
+    /** Returns `GET`, the HTTP method used by this request. */
+    getMethod() {
+      return HTTP_METHODS.get;
+    }
+  };
+  var GetByIdRequest = class extends ExecutableRequest {
+    /** Creates a single-item GET request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+    }
+    /** Returns `GET`, the HTTP method used by this request. */
+    getMethod() {
+      return HTTP_METHODS.get;
+    }
+  };
+  var DeleteRequest = class extends ExecutableRequest {
+    /** Creates a DELETE request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+    }
+    /** Returns `DELETE`, the HTTP method used by this request. */
+    getMethod() {
+      return HTTP_METHODS.delete;
+    }
+  };
+  var UpdateRequest = class extends ExecutableRequest {
+    /** Creates an update request, optionally using the Sitefinity temporary-save operation. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.data = requestOptions.data;
+      this.saveTemp = requestOptions.saveTemp;
+    }
+    /** Returns `PATCH`, the HTTP method used by this request. */
+    getMethod() {
+      return HTTP_METHODS.patch;
+    }
+    /** Returns the update payload after converting date values to ISO strings. */
+    getBody() {
+      const body = utils.convertDateFieldToISOString(this.data);
+      return body;
+    }
+    getHeaders() {
+      const headers = super.getHeaders();
+      if (this.saveTemp) {
+        headers[HEADER_NAMES.operation] = "SaveTemp";
+      }
+      return headers;
+    }
+  };
+  var CreateRequest = class extends ExecutableRequest {
+    /** Creates a request containing the item data to post. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.data = requestOptions.data;
+    }
+    /** Returns `POST`, the HTTP method used by this request. */
+    getMethod() {
+      return HTTP_METHODS.post;
+    }
+    /** Returns the create payload after converting date values to ISO strings. */
+    getBody() {
+      if (!(this.data instanceof File)) {
+        return utils.convertDateFieldToISOString(this.data);
+      }
+      return this.data;
+    }
+  };
+  var GetRelatedRequest = class extends GetByIdRequest {
+    /** Creates a related-property GET request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.property = requestOptions.property;
+    }
+    buildUrl() {
+      const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property;
+      return this.addQueryParameters(url);
+    }
+  };
+  var GetRelatedByIdRequest = class extends GetByIdRequest {
+    /** Creates a related-item GET request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.property = requestOptions.property;
+      this.relatedId = requestOptions.relatedId;
+    }
+    buildUrl() {
+      const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "(" + this.relatedId + ")";
+      return this.addQueryParameters(url);
+    }
+  };
+  var DeleteRelatedRequest = class extends DeleteRequest {
+    /** Creates a related-property DELETE request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.property = requestOptions.property;
+    }
+    buildUrl() {
+      const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref";
+      return this.addQueryParameters(url);
+    }
+  };
+  var DeleteRelatedByIdRequest = class extends DeleteRequest {
+    /** Creates a related-item DELETE request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.property = requestOptions.property;
+      this.relatedId = requestOptions.relatedId;
+    }
+    buildUrl() {
+      const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "(" + this.relatedId + ")/$ref";
+      return this.addQueryParameters(url);
+    }
+  };
+  var CreateRelatedRequest = class extends CreateRequest {
+    /** Creates a related-property POST request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.property = requestOptions.property;
+      this.key = requestOptions.key;
+    }
+    buildUrl() {
+      const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref";
+      return this.addQueryParameters(url);
+    }
+  };
+  var UploadRequest = class extends CreateRequest {
+    /** Creates an upload request with MIME type, file name, and upload properties. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.fileName = requestOptions.fileName;
+      this.uploadProperties = requestOptions.uploadProperties;
+      this.contentType = requestOptions.contentType;
+    }
+    /** Returns upload headers, including the MIME type, encoded file name, and properties. */
+    getHeaders() {
+      const headers = super.getHeaders();
+      headers[HEADER_NAMES.contentType] = this.contentType || "application/octet-stream";
+      headers[HEADER_NAMES.fileName] = encodeURIComponent(this.fileName);
+      headers[HEADER_NAMES.properties] = JSON.stringify(this.uploadProperties);
+      headers[HEADER_NAMES.contentEncoding] = "identity";
+      return headers;
+    }
+    /** Returns the binary upload payload without JSON date conversion. */
+    getBody() {
+      return this.data;
+    }
+    /** Returns `POST` for new files or `PATCH` when updating an existing item. */
+    getMethod() {
+      if (this.key) {
+        return HTTP_METHODS.patch;
+      }
+      return HTTP_METHODS.post;
+    }
+  };
+  var UploadChunkRequest = class extends CreateRequest {
+    /** Creates a chunk upload request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.contentType = requestOptions.fileMimeType;
+      this.chunkOrdinal = requestOptions.chunkOrdinal;
+      this.chunkedFileUploadSessionId = requestOptions.chunkedFileUploadSessionId;
+      this.chunkSize = requestOptions.chunkSize;
+      this.numberOfChunks = requestOptions.numberOfChunks;
+      this.positionInQueue = requestOptions.positionOfChunkInQueue;
+      this.blobStorageProviderName = requestOptions.blobStorageProviderName;
+      this.data = requestOptions.chunkBlob;
+      this.fileName = requestOptions.fileName;
+    }
+    /** Returns chunk headers required by the Sitefinity chunk upload service. */
+    getHeaders() {
+      const headers = super.getHeaders();
+      headers[HEADER_NAMES.contentEncoding] = "identity";
+      headers[HEADER_NAMES.contentType] = this.contentType || "application/octet-stream";
+      headers[HEADER_NAMES.chunkOrdinal] = this.chunkOrdinal.toString();
+      headers[HEADER_NAMES.chunkedFileUploadSessionId] = this.chunkedFileUploadSessionId;
+      headers[HEADER_NAMES.chunkSize] = this.chunkSize.toString();
+      headers[HEADER_NAMES.blobStorageProviderName] = this.blobStorageProviderName.toString();
+      headers[HEADER_NAMES.fileName] = encodeURIComponent(this.fileName);
+      return headers;
+    }
+    /** Returns the binary content of this chunk. */
+    getBody() {
+      return this.data;
+    }
+    /** Returns `POST`, the HTTP method used for a chunk. */
+    getMethod() {
+      return HTTP_METHODS.post;
+    }
+    /** Reports chunk progress as the position in the upload queue rather than bytes sent. */
+    getProgressPayload() {
+      return {
+        lengthComputable: true,
+        loaded: this.positionInQueue,
+        total: this.numberOfChunks
+      };
+    }
+  };
+  var CommitChunksRequest = class extends CreateRequest {
+    /** Creates a chunk-commit request and its server operation payload. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.action = "Default.CommitChunks";
+      this.data = {
+        // ! this must be the param name that the operation provider on the server accepts
+        commitChunksDto: {
+          chunkedFileUploadSessionId: requestOptions.chunkedFileUploadSessionId,
+          contentType: requestOptions.contentType,
+          fileTotalSize: requestOptions.fileTotalSize,
+          numberOfChunks: requestOptions.numberOfChunks,
+          fileName: requestOptions.fileName,
+          blobStorageProviderName: requestOptions.blobStorageProviderName,
+          itemId: requestOptions.itemId || null,
+          // ! must be named properties
+          properties: requestOptions.uploadProperties
+        }
+      };
+    }
+    /** Returns `POST`, the HTTP method used to commit the upload. */
+    getMethod() {
+      return HTTP_METHODS.post;
+    }
+  };
+
+  // src/Requests/BatchRequest.ts
+  var Transaction = class {
+    /** Creates an empty transaction using the batch URL options and request factory. */
+    constructor(urlOptions, factory) {
+      this.urlOptions = urlOptions;
+      this.factory = factory;
+      this.requests = [];
+      this.counter = 0;
+    }
+    /** Adds a file upload and returns its batch-local request ID. */
+    upload(parameters) {
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        data: parameters.data,
+        contentType: parameters.contentType,
+        fileName: parameters.fileName,
+        key: parameters.key,
+        uploadProperties: parameters.uploadProperties
+      };
+      const request = this.factory.upload(options);
+      return this.addRequest(request);
+    }
+    /**
+    * Adds a create request and returns its batch-local request ID.
+    *
+    * @throws When `entitySet` is missing.
+    */
+    create(parameters) {
+      if (!parameters?.entitySet)
+        throw "entitySet is required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        key: parameters.key,
+        action: parameters.action,
+        urlOptions,
+        data: parameters.data
+      };
+      const request = this.factory.create(options);
+      return this.addRequest(request);
+    }
+    // TODO: Remove
+    /** Adds an operation request. Validation errors are thrown when required values are missing. */
+    operation(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || !parameters.data)
+        throw "parameters: entitySet, key and data are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        action: "operation",
+        data: parameters.data
+      };
+      const request = this.factory.create(options);
+      this.overrideUrlGeneration(request, parameters.key, "operation", options.urlOptions, options.query);
+      this.addRequest(request);
+    }
+    /** Adds an update request. Validation errors are thrown when required values are missing. */
+    update(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || !parameters.data)
+        throw "parameters: entitySet, key and data are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        saveTemp: parameters.saveTemp,
+        key: parameters.key,
+        data: parameters.data
+      };
+      const request = this.factory.update(options);
+      this.overrideUrlGeneration(request, parameters.key, void 0, options.urlOptions, options.query);
+      this.addRequest(request);
+    }
+    /** Adds a delete request. Validation errors are thrown when required values are missing. */
+    destroy(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null)
+        throw "parameters: entitySet and key are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key
+      };
+      const request = this.factory.destroy(options);
+      this.overrideUrlGeneration(request, parameters.key, void 0, options.urlOptions, options.query);
+      this.addRequest(request);
+    }
+    /** Adds a request that removes all links in a related property. */
+    destroyRelated(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || !parameters.property)
+        throw "parameters: entitySet, key and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        property: parameters.property
+      };
+      const request = this.factory.destroyRelated(options);
+      const propertyURL = request.property + "/$ref";
+      this.overrideUrlGeneration(request, parameters.key, propertyURL, options.urlOptions, options.query);
+      this.addRequest(request);
+    }
+    /** Adds a request that removes one related link by key. */
+    destroyRelatedById(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || parameters.relatedId === void 0 || parameters.relatedId === null || !parameters.property)
+        throw "parameters: entitySet, key, relatedId and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        relatedId: parameters.relatedId,
+        property: parameters.property
+      };
+      const request = this.factory.destroyRelatedById(options);
+      this.addRequest(request);
+    }
+    /** Adds a related-link request and returns its batch-local request ID. */
+    createRelated(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || parameters.link === void 0 || parameters.link === null || !parameters.property)
+        throw "parameters: entitySet, key, link and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      for (let index = 0; index < this.requests.length; index += 1) {
+        if (this.requests[index].id == parameters.link) {
+          parameters.link = "$" + this.requests[index].id;
+        }
+      }
+      const data = {
+        "@odata.id": parameters.link
+      };
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        property: parameters.property,
+        data
+      };
+      const request = this.factory.createRelated(options);
+      const propertyURL = request.property + "/$ref";
+      this.overrideUrlGeneration(request, parameters.key, propertyURL, options.urlOptions, options.query);
+      return this.addRequest(request);
+    }
+    overrideUrlGeneration(request, key, additionalPropertyURL, urlOptions, query) {
+      for (let index = 0; index < this.requests.length; index += 1) {
+        if (this.requests[index].id == key) {
+          request.buildUrl = function() {
+            let uri = "$" + key;
+            if (additionalPropertyURL !== void 0) {
+              uri = uri + "/" + additionalPropertyURL;
+            }
+            if (urlOptions) {
+              const queryString = request.getQueryString(urlOptions, query);
+              if (queryString) {
+                uri = uri + queryString;
+              }
+            }
+            return uri;
+          };
+        }
+      }
+    }
+    addRequest(request) {
+      this.requests.push({ id: this.counter, request });
+      return this.counter++;
+    }
+    urlParametersClone(entitySet) {
+      const options = utils.clone(this.urlOptions);
+      options.entitySet = entitySet;
+      return options;
+    }
+  };
+  var _BatchRequest = class _BatchRequest extends ExecutableRequest {
+    /** Creates an empty batch request. */
+    constructor(requestOptions, token, sdkOptions) {
+      super(requestOptions, token, sdkOptions);
+      this.factory = requestOptions.factory;
+      this.requests = [];
+      this.counter = 0;
+      this.boundary = this.createBoundary("sf_batch_");
+      this.responseHeaderRegex = /^([^()<>@,;:\\"\/[\]?={} \t]+)\s?:\s?(.*)/;
+      this.responseStatusRegex = /^HTTP\/1\.\d (\d{3}) (.*)$/i;
+    }
+    /** Adds a collection GET request. Validation errors are thrown for missing `entitySet`. */
+    get(parameters) {
+      if (!parameters?.entitySet)
+        throw "entitySet is required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        action: parameters.action,
+        query: parameters.query,
+        fallbackProperties: parameters.fallbackProperties
+      };
+      const request = this.factory.get(options);
+      this.addRequest(request);
+    }
+    /** Adds a single-item GET request. Validation errors are thrown for missing keys. */
+    getSingle(parameters) {
+      if (!parameters || !parameters.entitySet || parameters.key === null || parameters.key === void 0)
+        throw "parameters: entitySet and key are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        action: parameters.action,
+        key: parameters.key,
+        query: parameters.query
+      };
+      const request = this.factory.getSingle(options);
+      this.addRequest(request);
+    }
+    /** Adds a related-property GET request. */
+    getProperty(parameters) {
+      if (!parameters || !parameters.entitySet || parameters.key === null || parameters.key === void 0 || !parameters.property)
+        throw "parameters: entitySet, key and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        property: parameters.property
+      };
+      const request = this.factory.getProperty(options);
+      this.addRequest(request);
+    }
+    /** Adds a related-items GET request. */
+    getRelated(parameters) {
+      if (!parameters || !parameters.entitySet || parameters.key === null || parameters.key === void 0 || !parameters.property)
+        throw "parameters: entitySet, key and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        property: parameters.property
+      };
+      const request = this.factory.getRelated(options);
+      this.addRequest(request);
+    }
+    /** Adds a GET request for one related item by key. */
+    getRelatedById(parameters) {
+      if (!parameters?.entitySet || parameters.key === void 0 || parameters.key === null || parameters.relatedId === void 0 || parameters.relatedId === null || !parameters.property)
+        throw "parameters: entitySet, key, relatedId and property are required!";
+      const urlOptions = this.urlParametersClone(parameters.entitySet);
+      const options = {
+        urlOptions,
+        key: parameters.key,
+        relatedId: parameters.relatedId,
+        property: parameters.property
+      };
+      const request = this.factory.getRelatedById(options);
+      this.addRequest(request);
+    }
+    /** Starts an atomic transaction changeset to add to this batch. */
+    beginTransaction() {
+      const option = utils.clone(this.urlOptions);
+      const newTransaction = new Transaction(option, this.factory);
+      newTransaction.id = ++this.counter;
+      return newTransaction;
+    }
+    /** Adds a transaction changeset to the batch. Empty transactions are omitted from the body. */
+    endTransaction(transaction) {
+      this.requests.push({
+        id: transaction.id,
+        request: transaction
+      });
+    }
+    /** Builds the multipart MIME body sent to the `$batch` endpoint. */
+    getBody() {
+      return this.buildRequestBody();
+    }
+    /** Returns `POST`, the HTTP method used for the `$batch` endpoint. */
+    getMethod() {
+      return HTTP_METHODS.post;
+    }
+    /** Returns headers with the generated multipart MIME content type. */
+    getHeaders() {
+      const headers = this.urlOptions.additionalHeaders ?? {};
+      const contentType = "multipart/mixed; boundary=" + this.boundary;
+      headers[HEADER_NAMES.contentType] = contentType;
+      return headers;
+    }
+    /** Builds the `$batch` URL and appends any configured query parameters. */
+    buildUrl() {
+      let url = this.urlOptions.baseUrl + "$batch";
+      const queryString = this.getQueryString(this.urlOptions, this.query);
+      if (queryString) {
+        url += queryString;
+      }
+      return url;
+    }
+    parseResponse(response) {
+      const context = {
+        position: 0,
+        boundaries: []
+      };
+      const partContentType = this.contentType(response.headers["content-type"]);
+      if (partContentType && partContentType.mediaType == "multipart/mixed") {
+        context.boundaries.push(partContentType.properties.boundary);
+      }
+      const batchResponse = this.parseBatchResponse(response.body, context);
+      const responseParsed = [];
+      for (let i = 0; i < batchResponse.length; i++) {
+        try {
+          const currentRequest = this.requests[i];
+          let finalResult = null;
+          let key = null;
+          const singleResponse = batchResponse[i];
+          const changesets = singleResponse.__changeResponses;
+          if (changesets) {
+            finalResult = [];
+            const currentRequests = currentRequest ? currentRequest.request.requests : [];
+            for (let j = 0; j < changesets.length; j++) {
+              key = currentRequests[j] ? currentRequests[j].request.key : null;
+              const changeset = changesets[j];
+              const response2 = changeset.response;
+              const responseResult = this.getResponseResult(response2, key);
+              finalResult.push(responseResult);
+            }
+          } else {
+            key = currentRequest ? currentRequest.request.key : null;
+            const response2 = singleResponse.response;
+            finalResult = this.getResponseResult(response2, key);
+          }
+          const statusCodeCheck = function(r) {
+            return r.statusCode >= 400;
+          };
+          const responseCheck = function(r) {
+            let success = true;
+            if (r.data && r.data.hasOwnProperty("Success")) {
+              success = r.data.Success;
+            }
+            return success;
+          };
+          const isSuccessful = Array.isArray(finalResult) ? finalResult.filter(statusCodeCheck).length === 0 && finalResult.filter(responseCheck).length === finalResult.length : !statusCodeCheck(finalResult) && responseCheck(finalResult);
+          responseParsed.push({ isSuccessful, response: finalResult });
+        } catch (e) {
+          continue;
+        }
+      }
+      const isSuccessfulCheck = (r) => {
+        return !r.isSuccessful;
+      };
+      const batchIsSuccessful = responseParsed.filter(isSuccessfulCheck).length === 0;
+      return { data: responseParsed, isSuccessful: batchIsSuccessful };
+    }
+    parseBatchResponse(text, context) {
+      const delimiter = "--" + this.currentBoundary(context);
+      this.readTo(text, delimiter, context);
+      this.readLine(text, context);
+      const responses = [];
+      let partEnd;
+      while (partEnd !== "--" && context.position < text.length) {
+        const partHeaders = this.readHeaders(text, context);
+        const partContentType = this.contentType(partHeaders["content-type"]);
+        let changeResponses;
+        if (partContentType && partContentType.mediaType === "multipart/mixed") {
+          context.boundaries.push(partContentType.properties.boundary);
+          try {
+            changeResponses = this.parseBatchResponse(text, context);
+          } catch (e) {
+            e.response = this.readResponse(text, context, delimiter);
+            changeResponses = [e];
+          }
+          responses.push({ __changeResponses: changeResponses });
+          context.boundaries.pop();
+          this.readTo(text, "--" + this.currentBoundary(context), context);
+        } else {
+          if (!partContentType || partContentType.mediaType !== "application/http") {
+            throw { message: "invalid MIME part type " };
+          }
+          this.readLine(text, context);
+          let response = this.readResponse(text, context, delimiter);
+          try {
+            if (response.statusCode >= 200 && response.statusCode <= 299) {
+              response = { message: response.statusCode + " Http request is OK", response };
+            } else {
+              response = { message: "HTTP request failed", response };
+            }
+          } catch (e) {
+            response = e;
+          }
+          responses.push(response);
+        }
+        partEnd = text.substr(context.position, 2);
+        this.readLine(text, context);
+      }
+      return responses;
+    }
+    getResponseResult(response, key) {
+      const responseBody = response.body;
+      const data = utils.parseStringToJson(responseBody);
+      return {
+        key,
+        data,
+        statusCode: response.statusCode,
+        headers: response.headers
+      };
+    }
+    currentBoundary(context) {
+      const boundaries = context.boundaries;
+      return boundaries[boundaries.length - 1];
+    }
+    contentType(str) {
+      if (!str) {
+        return null;
+      }
+      const contentTypeParts = str.split(";");
+      const properties = {};
+      let i, len;
+      for (i = 1, len = contentTypeParts.length; i < len; i++) {
+        const contentTypeParams = contentTypeParts[i].split("=");
+        properties[contentTypeParams[0].replace(/^\s+|\s+$/g, "")] = contentTypeParams[1];
+      }
+      return { mediaType: contentTypeParts[0].replace(/^\s+|\s+$/g, ""), properties };
+    }
+    readTo(text, str, context) {
+      const start = context.position || 0;
+      let end = text.length;
+      if (str) {
+        end = text.indexOf(str, start);
+        if (end === -1) {
+          return null;
+        }
+        context.position = end + str.length;
+      } else {
+        context.position = end;
+      }
+      return text.substring(start, end);
+    }
+    readLine(text, context) {
+      return this.readTo(text, _BatchRequest.constants.newLine, context);
+    }
+    readHeaders(text, context) {
+      const headers = {};
+      let parts;
+      let line;
+      let pos;
+      do {
+        pos = context.position;
+        line = this.readLine(text, context);
+        parts = this.responseHeaderRegex.exec(line);
+        if (parts !== null) {
+          headers[parts[1].toLowerCase()] = parts[2];
+        } else {
+          context.position = pos;
+        }
+      } while (line && parts);
+      return headers;
+    }
+    readResponse(text, context, delimiter) {
+      const pos = context.position;
+      const match = this.responseStatusRegex.exec(this.readLine(text, context));
+      let statusCode;
+      let statusText;
+      let headers;
+      if (match) {
+        statusCode = match[1];
+        statusText = match[2];
+        headers = this.readHeaders(text, context);
+        this.readLine(text, context);
+      } else {
+        context.position = pos;
+      }
+      return {
+        statusCode,
+        statusText,
+        headers,
+        body: this.readTo(text, _BatchRequest.constants.newLine + delimiter, context)
+      };
+    }
+    buildRequestBody() {
+      const builder = new BlobBuilder();
+      builder.append("");
+      for (let index = 0; index < this.requests.length; index += 1) {
+        const request = this.requests[index].request;
+        if (request instanceof Transaction && request.requests.length === 0) {
+          continue;
+        }
+        if (index != 0)
+          builder.append(_BatchRequest.constants.newLine + _BatchRequest.constants.newLine);
+        builder.append("--" + this.boundary);
+        if (request instanceof Transaction) {
+          builder.append(this.buildTransaction(request));
+        } else {
+          builder.append(this.buildRequest(request));
+        }
+      }
+      builder.append(this.createDelimeter(this.boundary, true));
+      return builder.build();
+    }
+    buildRequest(request) {
+      const builder = new BlobBuilder();
+      builder.append(_BatchRequest.constants.newLine + "Content-Type: application/http" + _BatchRequest.constants.newLine + "Content-Transfer-Encoding: binary" + _BatchRequest.constants.newLine + _BatchRequest.constants.newLine + request.getMethod() + " " + request.buildUrl() + " HTTP/1.1");
+      return builder.build();
+    }
+    buildTransaction(transaction) {
+      if (transaction.requests.length == 0)
+        return;
+      const builder = new BlobBuilder();
+      builder.append(_BatchRequest.constants.newLine);
+      const changeset = this.createBoundary("sf_changeset_");
+      builder.append("Content-Type: multipart/mixed; boundary=" + changeset);
+      const changesetRequests = transaction.requests;
+      for (let index = 0; index < changesetRequests.length; index += 1) {
+        const currentRequest = changesetRequests[index].request;
+        const shouldAddSingleNewLine = index != 0 && utils.isBlob(changesetRequests[index - 1].request.getBody());
+        builder.append(this.createDelimeter(changeset, false, shouldAddSingleNewLine) + _BatchRequest.constants.newLine + "Content-Type: application/http" + _BatchRequest.constants.newLine + "Content-Transfer-Encoding: binary" + _BatchRequest.constants.newLine + "Content-ID: " + changesetRequests[index].id);
+        const requestUrl = currentRequest.buildUrl();
+        builder.append(_BatchRequest.constants.newLine + _BatchRequest.constants.newLine + currentRequest.getMethod() + " " + requestUrl + " HTTP/1.1");
+        const headers = currentRequest.getHeaders();
+        const headerNames = Object.keys(headers);
+        for (let i = 0; i < headerNames.length; i++) {
+          const headerName = headerNames[i];
+          builder.append(_BatchRequest.constants.newLine + headerName + ": " + headers[headerName]);
+        }
+        const body = utils.serializeToJSON(currentRequest.getBody());
+        if (body) {
+          builder.append(_BatchRequest.constants.newLine + _BatchRequest.constants.newLine);
+          builder.append(body);
+        }
+      }
+      builder.append(this.createDelimeter(changeset, true));
+      return builder.build();
+    }
+    createDelimeter(boundary, close, shouldAddSingleNewLine = false) {
+      let result = _BatchRequest.constants.newLine;
+      if (!shouldAddSingleNewLine) {
+        result += _BatchRequest.constants.newLine;
+      }
+      result += "--" + boundary;
+      if (close) {
+        result += "--";
+        result += _BatchRequest.constants.newLine;
+      }
+      return result;
+    }
+    createBoundary(prefix) {
+      return prefix + utils.hex16() + "-" + utils.hex16() + "-" + utils.hex16();
+    }
+    addRequest(request) {
+      this.requests.push({ id: this.counter, request });
+      return this.counter++;
+    }
+    urlParametersClone(entitySet) {
+      const options = utils.clone(this.urlOptions);
+      options.entitySet = entitySet;
+      return options;
+    }
+  };
+  /** Protocol constants used when constructing multipart MIME content. */
+  _BatchRequest.constants = {
+    newLine: "\r\n"
+  };
+  var BatchRequest = _BatchRequest;
+
+  // src/Requests/RequestFactory.ts
+  var RequestFactory = class {
+    /** Creates a request factory using the supplied SDK-wide options. */
+    constructor(options) {
+      this.options = options;
+    }
+    /** Creates a request for retrieving a collection. */
+    get(parameters) {
+      return new GetRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for retrieving one item by key. */
+    getSingle(parameters) {
+      return new GetByIdRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for creating one item. */
+    create(parameters) {
+      return new CreateRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for updating one item. */
+    update(parameters) {
+      return new UpdateRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for deleting one item. */
+    destroy(parameters) {
+      return new DeleteRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for retrieving a related property value. */
+    getProperty(parameters) {
+      return new GetRelatedRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for retrieving related items. */
+    getRelated(parameters) {
+      return new GetRelatedRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for retrieving one related item by key. */
+    getRelatedById(parameters) {
+      return new GetRelatedByIdRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for removing all related links for a property. */
+    destroyRelated(parameters) {
+      return new DeleteRelatedRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for removing one related link by key. */
+    destroyRelatedById(parameters) {
+      return new DeleteRelatedByIdRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for adding a related link. */
+    createRelated(parameters) {
+      return new CreateRelatedRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for uploading a file or binary payload. */
+    upload(parameters) {
+      return new UploadRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request for uploading one file chunk. */
+    uploadChunk(parameters) {
+      return new UploadChunkRequest(parameters, this.token, this.options);
+    }
+    /** Creates a request that commits an uploaded chunk session. */
+    commitChunks(parameters) {
+      return new CommitChunksRequest(parameters, this.token, this.options);
+    }
+    /** Creates a multipart batch request; call its methods to add operations, then call `execute()`. */
+    batch(parameters) {
+      const batchParams = parameters;
+      batchParams.factory = this;
+      return new BatchRequest(batchParams, this.token, this.options);
+    }
+  };
+
+  // src/chunk-upload/chunked-file-upload.utilities.ts
+  var ChunkedFileUploadUtilities = class {
+    /**
+     * Splits a `Blob` or base64-encoded binary string into sequential chunks.
+     *
+     * Blob input is sliced directly. A base64 string is decoded with `atob`
+     * into a Blob using `contentTypeMime` before it is sliced. Chunk ordinals
+     * start at zero; the final chunk can be smaller than `chunkSize`.
+     *
+     * @param file Blob data or a base64-encoded binary string.
+     * @param chunkSize Maximum size of each chunk in bytes.
+     * @param contentTypeMime MIME type assigned to each chunk and decoded Blob.
+     * @returns The chunks, their total count, and the original file size in bytes.
+     *
+     * @example
+     * ```ts
+     * const result = new ChunkedFileUploadUtilities().chunkFile(
+     *     base64File,
+     *     5 * 1024 * 1024,
+     *     "image/jpeg"
+     * );
+     *
+     * result.chunks.forEach(({ ordinal, content }) => {
+     *     console.log(`Chunk ${ordinal}: ${content.size} bytes`);
+     * });
+     * ```
+     */
+    chunkFile(file, chunkSize, contentTypeMime) {
+      let fileInternal;
+      if (typeof file === "string")
+        fileInternal = this.base64ToBlob(file, chunkSize, contentTypeMime);
+      else {
+        fileInternal = file;
+      }
+      const fileSize = fileInternal.size;
+      const result = [];
+      let chunkOrdinal = 0;
+      let offset = 0;
+      let currentOffset = chunkSize;
+      while (offset <= fileSize) {
+        const chunk = fileInternal.slice(offset, currentOffset, contentTypeMime);
+        offset = currentOffset;
+        currentOffset = currentOffset + chunkSize;
+        result.push({
+          ordinal: chunkOrdinal,
+          content: chunk
+        });
+        chunkOrdinal++;
+      }
+      return {
+        chunks: result,
+        totalChunksCount: result.length,
+        fileTotalSize: fileSize
+      };
+    }
+    /**
+     * Converts base64 binary content to a Blob before chunking.
+     *
+     * The input must contain the base64 payload expected by `atob`; a data URL
+     * prefix is not removed automatically.
+     */
+    base64ToBlob(base64String, chunkSize, contentType = "") {
+      const byteCharacters = atob(base64String);
+      const byteArrays = [];
+      for (let offset = 0; offset < byteCharacters.length; offset += chunkSize) {
+        const slice = byteCharacters.slice(offset, offset + chunkSize);
+        const byteNumbers = new Array(slice.length);
+        for (let i = 0; i < slice.length; i++) {
+          byteNumbers[i] = slice.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        byteArrays.push(byteArray);
+      }
+      const blob = new Blob(byteArrays, { type: contentType });
+      return blob;
+    }
+  };
+
+  // src/chunk-upload/chunk-upload.sdk.ts
+  var ChunkUploadSdk = class {
+    constructor(urlOptions, factory) {
+      this.urlOptions = urlOptions;
+      this.factory = factory;
+    }
+    /**
+     * Gets the session, provider, and chunk settings required to start an upload.
+     *
+     * The `data.libraryId` field must identify the parent library, not a library
+     * folder. The inherited callbacks and query options are optional.
+     *
+     * @param parameters Request data and optional callbacks.
+     * @param parameters.data.libraryId Parent library identifier.
+     * @param parameters.successCb Receives a {@link ChunkUploadInfoDTO} on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    getChunkUploadInfo(parameters) {
+      Guard.isNotNull(parameters, "parameters");
+      Guard.isNotNull(parameters.data, "parameters.data");
+      Guard.isNotNull(parameters.data.libraryId, "parameters.data.libraryId");
+      const options = {
+        urlOptions: this.urlOptions,
+        action: `Default.GetChunkUploadInfo(libraryId=${parameters.data.libraryId})`,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        progressCb: parameters.progressCb,
+        fallbackProperties: parameters.fallbackProperties,
+        query: parameters.query
+      };
+      const request = this.factory.get(options);
+      request.execute();
+    }
+    /**
+     * Sends one chunk to the server.
+     *
+     * Upload chunks in ordinal order from `0` through `numberOfChunks - 1`.
+     * `chunkSize` is the chunk size in bytes, while `chunkBlob` contains the
+     * current chunk and may be smaller for the final chunk. The session,
+     * provider, ordinal, count, size, and blob fields are required.
+     *
+     * @param parameters Chunk data and optional callbacks.
+     * @param parameters.data.fileMimeType MIME type of the complete file.
+     * @param parameters.data.fileName File name sent with the chunk.
+     * @param parameters.data.chunkedFileUploadSessionId Session from
+     * `getChunkUploadInfo`.
+     * @param parameters.data.chunkSize Size of this chunk in bytes.
+     * @param parameters.data.chunkOrdinal Zero-based ordinal of this chunk.
+     * @param parameters.data.numberOfChunks Total chunks in the upload.
+     * @param parameters.data.positionOfChunkInQueue Optional queue position used
+     * to calculate progress for concurrent uploads.
+     * @param parameters.data.chunkBlob Bytes for this chunk.
+     * @param parameters.data.blobStorageProviderName Provider from the upload info.
+     * @param parameters.successCb Receives a {@link ChunkUploadResult} on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    uploadChunk(parameters) {
+      Guard.isNotNull(parameters, "parameters");
+      Guard.isNotNull(parameters.data, "parameters.data");
+      Guard.isNotNull(parameters.data.chunkSize, "parameters.data.chunkSize");
+      Guard.isNotNull(parameters.data.chunkedFileUploadSessionId, "parameters.data.chunkedFileUploadSessionId");
+      Guard.isNotNull(parameters.data.chunkOrdinal, "parameters.data.chunkOrdinal");
+      Guard.isNotNull(parameters.data.numberOfChunks, "parameters.data.numberOfChunks");
+      Guard.isNotNull(parameters.data.chunkBlob, "parameters.data.chunkBlob");
+      Guard.isNotNull(parameters.data.blobStorageProviderName, "parameters.data.blobStorageProviderName");
+      const request = this.factory.uploadChunk({
+        urlOptions: this.urlOptions,
+        fileMimeType: parameters.data.fileMimeType,
+        chunkSize: parameters.data.chunkSize,
+        chunkedFileUploadSessionId: parameters.data.chunkedFileUploadSessionId,
+        chunkOrdinal: parameters.data.chunkOrdinal,
+        numberOfChunks: parameters.data.numberOfChunks,
+        chunkBlob: parameters.data.chunkBlob,
+        blobStorageProviderName: parameters.data.blobStorageProviderName,
+        fileName: parameters.data.fileName,
+        // optional
+        positionOfChunkInQueue: parameters.data.positionOfChunkInQueue,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        progressCb: parameters.progressCb,
+        fallbackProperties: parameters.fallbackProperties,
+        query: parameters.query
+      });
+      request.execute();
+    }
+    /**
+     * Commits all uploaded chunks as one media file.
+     *
+     * Call this only after every ordinal has uploaded successfully. The server
+     * validates `numberOfChunks` and `fileTotalSize` before assembling the file.
+     * Set `data.itemId` when replacing an existing media item; omit it when
+     * creating a new item. A successful commit completes the upload session.
+     *
+     * @param parameters Commit data and optional callbacks.
+     * @param parameters.data.chunkedFileUploadSessionId Session used by the chunks.
+     * @param parameters.data.contentType MIME type of the complete file.
+     * @param parameters.data.fileTotalSize Complete file size in bytes.
+     * @param parameters.data.numberOfChunks Number of uploaded chunks.
+     * @param parameters.data.name File name.
+     * @param parameters.data.blobStorageProviderName Provider used for the chunks.
+     * @param parameters.data.uploadProperties Media item properties such as
+     * `Title` and `UrlName`.
+     * @param parameters.data.itemId Optional existing item identifier for updates.
+     * @param parameters.successCb Receives the commit response on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    commitChunks(parameters) {
+      Guard.isNotNull(parameters, "parameters");
+      Guard.isNotNull(parameters.data, "parameters.data");
+      Guard.isNotNull(parameters.data.chunkedFileUploadSessionId, "parameters.data.chunkedFileUploadSessionId");
+      Guard.isNotNull(parameters.data.name, "parameters.data.name");
+      Guard.isNotNull(parameters.data.uploadProperties, "parameters.data.uploadProperties");
+      Guard.isNotNull(parameters.data.numberOfChunks, "parameters.data.numberOfChunks");
+      Guard.isNotNull(parameters.data.fileTotalSize, "parameters.data.fileTotalSize");
+      Guard.isNotNull(parameters.data.blobStorageProviderName, "parameters.data.blobStorageProviderName");
+      const options = {
+        urlOptions: this.urlOptions,
+        chunkedFileUploadSessionId: parameters.data.chunkedFileUploadSessionId,
+        contentType: parameters.data.contentType,
+        fileName: parameters.data.name,
+        uploadProperties: parameters.data.uploadProperties,
+        numberOfChunks: parameters.data.numberOfChunks,
+        fileTotalSize: parameters.data.fileTotalSize,
+        blobStorageProviderName: parameters.data.blobStorageProviderName,
+        // Optional: used for update, can be null for create
+        itemId: parameters.data.itemId,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        progressCb: parameters.progressCb,
+        fallbackProperties: parameters.fallbackProperties,
+        query: parameters.query
+      };
+      const request = this.factory.commitChunks(options);
+      request.execute();
+    }
+    /**
+     * Deletes all chunks associated with an incomplete upload session.
+     *
+     * Call this after a failed chunk upload or failed commit when the session
+     * should not be resumed. Cleanup does not commit a file and requires the
+     * session and provider used by the upload.
+     *
+     * @param parameters Session data and optional callbacks.
+     * @param parameters.data.chunkedFileUploadSessionId Session to clean up.
+     * @param parameters.data.blobStorageProviderName Provider holding the chunks.
+     * @param parameters.successCb Called after cleanup succeeds.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives request progress events when supported.
+     */
+    cleanUpChunks(parameters) {
+      Guard.isNotNull(parameters, "parameters");
+      Guard.isNotNull(parameters.data, "parameters.data");
+      Guard.isNotNull(parameters.data.chunkedFileUploadSessionId, "parameters.data.chunkedFileUploadSessionId");
+      Guard.isNotNull(parameters.data.blobStorageProviderName, "parameters.data.blobStorageProviderName");
+      const request = this.factory.create({
+        urlOptions: this.urlOptions,
+        action: "Default.CleanUpChunks",
+        data: {
+          chunkedFileUploadSessionId: parameters.data.chunkedFileUploadSessionId,
+          blobStorageProviderName: parameters.data.blobStorageProviderName
+        },
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        progressCb: parameters.progressCb,
+        fallbackProperties: parameters.fallbackProperties,
+        query: parameters.query
+      });
+      request.execute();
+    }
+    /**
+     * Splits a file into uploadable chunks.
+     *
+     * A `Blob` is sliced directly. A base64 string is decoded with `atob` into
+     * a `Blob` using `contentTypeMime`, then sliced. Each returned chunk has a
+     * zero-based ordinal, and the last chunk can be smaller than `chunkSize`.
+     *
+     * @param file Source `Blob` or base64-encoded binary string.
+     * @param chunkSize Maximum chunk size in bytes.
+     * @param contentTypeMime MIME type assigned to the chunks and decoded Blob.
+     * @returns Chunk blobs, their zero-based ordinals, total count, and file size.
+     *
+     * @example
+     * ```ts
+     * const upload = sitefinity.data(typeOptions).chunkUpload;
+     * const result = upload.chunkFile(file, 5 * 1024 * 1024, "image/jpeg");
+     *
+     * for (const chunk of result.chunks) {
+     *     upload.uploadChunk({
+     *         data: {
+     *             fileMimeType: "image/jpeg",
+     *             chunkedFileUploadSessionId: sessionId,
+     *             chunkSize: chunk.content.size,
+     *             chunkOrdinal: chunk.ordinal,
+     *             numberOfChunks: result.totalChunksCount,
+     *             chunkBlob: chunk.content,
+     *             blobStorageProviderName: providerName
+     *         },
+     *         successCb: onChunkUploaded,
+     *         failureCb: onUploadFailed
+     *     });
+     * }
+     * ```
+     */
+    chunkFile(file, chunkSize, contentTypeMime) {
+      Guard.isNotNull(file, "file");
+      Guard.isNotNull(chunkSize, "chunkSize");
+      const utils2 = new ChunkedFileUploadUtilities();
+      return utils2.chunkFile(file, chunkSize, contentTypeMime);
+    }
+  };
+  var Guard = class _Guard {
+    static isNotNull(value, parameterName) {
+      if (typeof value === "number") {
+        return;
+      }
+      if (!value) {
+        _Guard.throwException(parameterName);
+      }
+    }
+    static throwException(parameterName) {
+      throw `parameter ${parameterName} is required.`;
+    }
+  };
+
+  // src/Data.ts
+  var Data = class {
+    /**
+     * Creates an entity-set data client.
+     *
+     * @param urlOptions Entity-set and request URL options.
+     * @param factory Internal request factory used to create SDK requests.
+     */
+    constructor(urlOptions, factory) {
+      this.urlOptions = urlOptions;
+      this.factory = factory;
+    }
+    /**
+     * Returns the chunk-upload service for this entity set.
+     *
+     * Use it for uploads that must be sent in chunks and committed after all chunks
+     * complete. A new service instance is returned for each access.
+     *
+     * @returns The chunk-upload service.
+     */
+    get chunkUpload() {
+      const service = new ChunkUploadSdk(this.urlOptions, this.factory);
+      return service;
+    }
+    /**
+     * Executes a GET request to retrieve a collection of items.
+     *
+     * @param parameters Query, action, fallback-property, and callback options.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If request creation fails.
+     */
+    get(parameters) {
+      const request = this.factory.get({
+        urlOptions: this.urlOptions,
+        query: parameters.query,
+        action: parameters.action,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        fallbackProperties: parameters.fallbackProperties
+      });
+      request.execute();
+    }
+    /**
+     * Executes a GET request to retrieve operations for an item or its parent collection.
+     *
+     * When `key` is omitted, `parentId` is added to the operations URL.
+     *
+     * @param parameters Operation and callback options.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If the underlying request cannot be created.
+     */
+    getOperations(parameters) {
+      let request;
+      let action = "operations";
+      if (!parameters.key)
+        action += `?${SF_PARAMS.parentId}=` + parameters.parentId;
+      const params = {
+        urlOptions: this.urlOptions,
+        action,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      };
+      if (parameters.key) {
+        params.key = parameters.key;
+        request = this.factory.getSingle(params);
+      } else {
+        request = this.factory.get(params);
+      }
+      request.execute();
+    }
+    /**
+     * Executes a GET request for a single item.
+     *
+     * @param parameters Item key, query, action, and callback options.
+     * @returns Nothing. The item is delivered to `successCb` or `failureCb`.
+     * @throws If `key` is missing.
+     */
+    getSingle(parameters) {
+      if (!parameters.key)
+        throw "Parameter 'key' is required!";
+      const request = this.factory.getSingle({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        query: parameters.query,
+        action: parameters.action,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb,
+        fallbackProperties: parameters.fallbackProperties
+      });
+      request.execute();
+    }
+    /**
+     * Executes a POST request for a single item.
+     *
+     * @param parameters Item data, optional key/action, and callbacks.
+     * @returns Nothing. The created item or error is delivered to a callback.
+     * @throws If `data` is missing.
+     */
+    create(parameters) {
+      if (!parameters.data)
+        throw "Parameter 'data' is required!";
+      const request = this.factory.create({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        query: parameters.query,
+        data: parameters.data,
+        action: parameters.action,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a PATCH request to update a single item.
+     *
+     * @param parameters Item key, update data, optional temporary-save flag, and callbacks.
+     * @returns Nothing. The updated item or error is delivered to a callback.
+     * @throws If `key` or `data` is missing.
+     *
+     * @example
+     * const data = sf.data({
+     *     entitySet: "newsitems",
+     *     provider: "OpenAccessDataProvider",
+     *     culture: "en"
+     * });
+     *
+     * data.update({
+     *     key: "00000000-0000-0000-0000-000000000000",
+     *     data: { Title: "Updated news title" },
+     *     saveTemp: true,
+     *     successCb,
+     *     failureCb
+     * });
+     */
+    update(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.data)
+        throw "Parameters: 'data' and 'key' are required!";
+      const request = this.factory.update({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        data: parameters.data,
+        action: parameters.action,
+        saveTemp: parameters.saveTemp,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a DELETE request to delete a single item.
+     *
+     * @param parameters Item key, optional action, and callbacks.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If `key` is missing.
+     */
+    destroy(parameters) {
+      if (!parameters.key)
+        throw "Parameter 'key' is required!";
+      const request = this.factory.destroy({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        action: parameters.action,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a POST request to execute a workflow operation for a single item.
+     *
+     * @param parameters Item key, operation data, and callbacks.
+     * @returns Nothing. The operation result is delivered to a callback.
+     * @throws If `key` or `data` is missing.
+     */
+    operation(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.data)
+        throw "Parameters: 'data' and 'key' are required!";
+      const request = this.factory.create({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        action: "operation",
+        data: parameters.data,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a GET request to retrieve a property of a single item.
+     *
+     * @param parameters Item key, property name, and callbacks.
+     * @returns Nothing. The property value is delivered to a callback.
+     * @throws If `key` or `property` is missing.
+     */
+    getProperty(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property)
+        throw "Parameters: 'data' and 'property' are required!";
+      const request = this.factory.getProperty({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        property: parameters.property,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a GET request to retrieve a related property value of a single item.
+     *
+     * @param parameters Item key, relation property name, and callbacks.
+     * @returns Nothing. The related value is delivered to a callback.
+     * @throws If `key` or `property` is missing.
+     */
+    getRelated(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property)
+        throw "Parameters: 'data' and 'property' are required!";
+      const request = this.factory.getRelated({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        property: parameters.property,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a GET request to retrieve a related item by its ID.
+     *
+     * @param parameters Item key, relation property, related item ID, and callbacks.
+     * @returns Nothing. The related item is delivered to a callback.
+     * @throws If `key`, `property`, or `relatedId` is missing.
+     */
+    getRelatedById(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property || parameters.relatedId === void 0 || parameters.relatedId === null)
+        throw "Parameters: 'data', 'relatedId' and 'property' are required!";
+      const request = this.factory.getRelatedById({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        relatedId: parameters.relatedId,
+        property: parameters.property,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a DELETE request for all members associated with a relation property.
+     *
+     * @param parameters Item key, relation property, and callbacks.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If `key` or `property` is missing.
+     */
+    destroyRelated(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property)
+        throw "Parameters: 'data' and 'property' are required!";
+      const request = this.factory.destroyRelated({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        property: parameters.property,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a DELETE request for one member of a relation property.
+     *
+     * @param parameters Item key, relation property, related item ID, and callbacks.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If `key`, `property`, or `relatedId` is missing.
+     */
+    destroyRelatedById(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property || parameters.relatedId === void 0 || parameters.relatedId === null)
+        throw "Parameters: 'data', 'relatedId' and 'property' are required!";
+      const request = this.factory.destroyRelatedById({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        relatedId: parameters.relatedId,
+        property: parameters.property,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a POST request to add a related item to a property collection.
+     *
+     * @param parameters Item key, relation property, related item link, and callbacks.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If `key`, `property`, or `link` is missing.
+     */
+    createRelated(parameters) {
+      if (parameters.key === void 0 || parameters.key === null || !parameters.property || parameters.link === void 0 || parameters.link === null)
+        throw "Parameters: 'data', 'link' and 'property' are required!";
+      const data = {
+        "@odata.id": parameters.link
+      };
+      const request = this.factory.createRelated({
+        urlOptions: this.urlOptions,
+        key: parameters.key,
+        property: parameters.property,
+        data,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      });
+      request.execute();
+    }
+    /**
+     * Executes a POST request to upload a media item and optionally update or publish it.
+     *
+     * The SDK orchestrates the upload in a transaction. `content`, `contentType`, `name`,
+     * and `uploadProperties` are required. When `payload` is supplied, it updates the
+     * uploaded item; when `publish` is `true`, it then executes the `Publish` operation.
+     *
+     * @param parameters Upload data, optional post-upload payload, publish flag, and callbacks.
+     * @returns Nothing. The result is delivered to `successCb` or `failureCb`.
+     * @throws If required upload data is missing.
+     *
+     * @example
+     * const data = sf.data({ entitySet: "images" });
+     * data.upload({
+     *     data: {
+     *         content: "base64 file content",
+     *         contentType: "image/jpeg",
+     *         name: "test.jpg",
+     *         payload: { Title: "Test" },
+     *         uploadProperties: {
+     *             ParentId: "4BA7AD46-F29B-4E65-BE17-9BF7CE5BA1FB"
+     *         }
+     *     },
+     *     successCb,
+     *     failureCb
+     * });
+     */
+    upload(parameters) {
+      if (!parameters?.data?.content || !parameters.data.contentType || !parameters.data.name || !parameters.data.uploadProperties)
+        throw "parameters: content, contentType, name and uploadProperties are required!";
+      const options = {
+        urlOptions: this.urlOptions,
+        _factory: this.factory,
+        successCb: parameters.successCb,
+        failureCb: parameters.failureCb
+      };
+      const batch = this.factory.batch(options);
+      const transaction = batch.beginTransaction();
+      const uploadedFile = transaction.upload({
+        entitySet: this.urlOptions.entitySet,
+        data: parameters.data.content,
+        contentType: parameters.data.contentType,
+        fileName: parameters.data.name,
+        uploadProperties: parameters.data.uploadProperties
+      });
+      if (parameters.data.payload)
+        transaction.update({
+          entitySet: this.urlOptions.entitySet,
+          key: uploadedFile,
+          data: parameters.data.payload
+        });
+      if (parameters.publish === true) {
+        transaction.operation({
+          entitySet: this.urlOptions.entitySet,
+          key: uploadedFile,
+          data: {
+            action: "Publish"
+          }
+        });
+      }
+      batch.endTransaction(transaction);
+      return batch.execute();
+    }
+  };
+
+  // src/QueryBase.ts
+  var QueryBase = class {
+    /** Creates an empty projection. */
+    constructor() {
+      this.selectProperties = null;
+      this.expandProperties = null;
+    }
+    /**
+     * Selects the scalar fields returned by the service.
+     *
+     * Duplicate names are removed while preserving their first occurrence.
+     * Property names must be simple paths without a dot.
+     *
+     * @param properties Field names to include.
+     * @returns A cloned query with `$select` configured.
+     * @throws Error If a property is not a string or is a nested path.
+     */
+    select(...properties) {
+      properties = properties ?? [];
+      this.validatePropertyPaths(properties);
+      return this.clone((newObj) => {
+        newObj.selectProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
+      });
+    }
+    /**
+     * Selects the navigation properties expanded by the service.
+     *
+     * Duplicate names are removed while preserving their first occurrence.
+     * Property names must be simple paths without a dot.
+     *
+     * @param properties Navigation property names to expand.
+     * @returns A cloned query with `$expand` configured.
+     * @throws Error If a property is not a string or is a nested path.
+     */
+    expand(...properties) {
+      properties = properties ?? [];
+      this.validatePropertyPaths(properties);
+      return this.clone((newObj) => {
+        newObj.expandProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
+      });
+    }
+    validatePropertyPaths(propPaths, allowNested = false) {
+      for (let i = 0; i < propPaths.length; i++) {
+        const member = propPaths[i];
+        if (!utils.isString(member)) {
+          throw new Error("Invalid argument in clause");
+        }
+        if (!allowNested && member.indexOf(".") > -1) {
+          throw new Error("Invalid argument in clause");
+        }
+      }
+    }
+    clone(setter = null) {
+      const newObj = utils.clone(this, Object.create(Object.getPrototypeOf(this)), setter);
+      return newObj;
+    }
+  };
+
+  // src/OrderProperty.ts
+  var OrderProperty = class {
+    /**
+     * Creates an order-by descriptor.
+     *
+     * The property path may include a trailing `asc` or `desc` direction.
+     * Without a direction, ascending order is used.
+     *
+     * @param propertyPath Property name, optionally followed by `asc` or `desc`.
+     * @param isDesc Explicit direction override when supplied.
+     * @throws Error If the property name is not a string or the direction is invalid.
+     */
+    constructor(propertyPath, isDesc = null) {
+      this.propertyPath = propertyPath;
+      this.isDesc = isDesc;
+      if (!utils.isString(propertyPath))
+        throw new Error("Property name is not a valid string");
+      propertyPath = propertyPath.trim();
+      const parts = propertyPath.split(" ");
+      if (parts.length > 1 && isDesc !== true && isDesc !== false) {
+        isDesc = parts[1].toLowerCase() == "desc";
+        if (!isDesc) {
+          const isAsc = parts[1].toLowerCase() == "asc";
+          if (!isAsc) {
+            throw new Error("the second word in the propertyPath must begin with 'desc' or 'asc'");
+          }
+        }
+      }
+      this.propertyPath = parts[0];
+      this.isDesc = isDesc;
+    }
+    /** Returns the property name without its direction. */
+    getPropertyPath() {
+      return this.propertyPath;
+    }
+    /** Returns `true` for descending order and `false` for ascending order. */
+    getDirection() {
+      return this.isDesc;
+    }
+    /** Returns the normalized `property direction` string used in `$orderby`. */
+    getValue() {
+      const direction = this.isDesc ? "desc" : "asc";
+      return this.propertyPath + " " + direction;
+    }
+  };
+
+  // src/QueryBuilder.ts
+  var QueryBuilder = class {
+    /** Creates a builder for the supplied query. */
+    constructor(query) {
+      this.query = query;
+    }
+    /**
+     * Serializes the query into OData parameter names and values.
+     *
+     * Supported output keys are `$filter`, `$select`, `$expand`, `$orderby`,
+     * `$skip`, `$top`, `$count`, and `$search`. Missing or empty clauses are
+     * omitted. String constants are escaped and quoted; GUID constants remain
+     * unquoted, and `in` requires an array value.
+     *
+     * @returns An object suitable for the data request's query parameters.
+     * @throws Error If the expression tree is invalid, an operator is unsupported,
+     * or an `in` condition does not contain an array.
+     */
+    build() {
+      const queryParameters = {};
+      const whereClause = this.query.filter;
+      if (whereClause instanceof WhereQuery) {
+        const expression = whereClause.getExpression();
+        if (expression instanceof ComplexExpression) {
+          const result = this.buildComplexExpression(expression, null);
+          if (result) {
+            queryParameters[ODATA_PARAMS.$filter] = result;
+          }
+        }
+      }
+      const selectClause = this.query.selectProperties;
+      if (selectClause instanceof Array) {
+        queryParameters[ODATA_PARAMS.$select] = selectClause.join(", ");
+      }
+      const expandClause = this.query.expandProperties;
+      if (expandClause instanceof Array)
+        queryParameters[ODATA_PARAMS.$expand] = expandClause.join(", ");
+      const orderByClause = this.query.orderProperties;
+      if (orderByClause instanceof Array) {
+        const order = [];
+        for (const i in orderByClause) {
+          if (orderByClause[i] instanceof OrderProperty)
+            order.push(orderByClause[i].getValue());
+        }
+        queryParameters[ODATA_PARAMS.$orderby] = order.join(", ");
+      }
+      const take = this.query.takeValue;
+      if (utils.isNumber(take))
+        queryParameters[ODATA_PARAMS.$top] = take;
+      const skip = this.query.skipValue;
+      if (utils.isNumber(skip))
+        queryParameters[ODATA_PARAMS.$skip] = skip;
+      const search = this.query.searchValue;
+      if (search)
+        queryParameters[ODATA_PARAMS.$search] = search;
+      if (this.query.inlineCount !== null) {
+        queryParameters[ODATA_PARAMS.$count] = this.query.inlineCount;
+      }
+      return queryParameters;
+    }
+    buildComplexExpression(expression, parent) {
+      if (!(expression instanceof ComplexExpression))
+        throw new Error("Invalid complex expression");
+      let counter = 0;
+      let result = "";
+      const subExpressions = expression.getExpressions();
+      if (!subExpressions.length) {
+        return result;
+      }
+      while (true) {
+        const currentExp = subExpressions[counter];
+        if (currentExp instanceof BinaryExpression) {
+          result += this.buildBinaryExpression(currentExp);
+        } else if (currentExp instanceof ComplexExpression) {
+          const complexResult = this.buildComplexExpression(currentExp, expression.type);
+          if (complexResult) {
+            result += "(" + complexResult + ")";
+          }
+        }
+        if (expression.getType() === EXPRESSION_TYPE.not)
+          result = expression.getType() + " " + result;
+        if (expression.getType() === EXPRESSION_TYPE.any) {
+          const exprVal = [];
+          for (let index = 0; index < subExpressions.length; index++) {
+            if (subExpressions[index].type == EXPRESSION_TYPE.contains || subExpressions[index].type == EXPRESSION_TYPE.startsWith || subExpressions[index].type == EXPRESSION_TYPE.endsWith)
+              exprVal.push(subExpressions[index].type.toLowerCase() + "(x, '" + subExpressions[index].constant + "')");
+            else
+              exprVal.push("x " + subExpressions[index].type.toLowerCase() + " " + this.checkType(subExpressions[index].constant));
+          }
+          result = currentExp.parameter + "/" + expression.getType() + "(x:" + exprVal.join(" " + parent + " ") + ")";
+        }
+        counter++;
+        if (counter == subExpressions.length)
+          break;
+        result += " " + expression.getType() + " ";
+      }
+      return result;
+    }
+    buildBinaryExpression(expression) {
+      let result = null;
+      const type = expression.getType();
+      switch (type) {
+        case EXPRESSION_TYPE.eq:
+        case EXPRESSION_TYPE.ne:
+        case EXPRESSION_TYPE.lt:
+        case EXPRESSION_TYPE.le:
+        case EXPRESSION_TYPE.gt:
+        case EXPRESSION_TYPE.ge: {
+          const constant = expression.getConstant();
+          result = `(${expression.getParameter()} ${type} ${this.checkType(constant)})`;
+          break;
+        }
+        case EXPRESSION_TYPE.contains:
+        case EXPRESSION_TYPE.startsWith:
+        case EXPRESSION_TYPE.endsWith: {
+          const expressionParameter = this.applyCaseSensitiveSettings(expression, expression.getParameter());
+          const expressionConstant = this.checkType(expression.getConstant(), true);
+          const expressionValue = this.applyCaseSensitiveSettings(expression, expressionConstant);
+          result = `${type.toLowerCase()}(${expressionParameter}, ${expressionValue})`;
+          break;
+        }
+        case EXPRESSION_TYPE.in: {
+          const valueArray = expression.getConstant();
+          if (!Array.isArray(valueArray)) {
+            throw new Error("Parameter is not an array!");
+          }
+          result = `${expression.getParameter()} in (${valueArray.join(", ")})`;
+          break;
+        }
+        default: {
+          const msg = `Unsupported operator ${type}`;
+          throw new Error(msg);
+        }
+      }
+      return result;
+    }
+    applyCaseSensitiveSettings(expression, value) {
+      if (expression.isCaseSensitive()) {
+        return value;
+      }
+      return `tolower(${value})`;
+    }
+    checkType(constant, treatAsString = false) {
+      if (this.isGuid(constant) && !treatAsString)
+        return constant;
+      if (constant == null)
+        return null;
+      constant = constant.replace(/[+/?%#&]/g, function($0) {
+        return encodeURIComponent($0);
+      });
+      constant = constant.replace(/'/g, "''");
+      return "'" + constant + "'";
+    }
+    isGuid(constant) {
+      return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(constant);
+    }
+  };
+
+  // src/Query.ts
+  var Query = class extends QueryBase {
+    /** Creates an empty query with no selected fields, filters, ordering, or paging. */
+    constructor() {
+      super();
+      /** The order-by clauses, when an order has been configured. */
+      this.orderProperties = null;
+      /** The number of records to skip, when paging is configured. */
+      this.skipValue = null;
+      /** The maximum number of records to return, when paging is configured. */
+      this.takeValue = null;
+      /** The full-text search expression, when configured. */
+      this.searchValue = null;
+      /** The root filter expression, when a where clause has been configured. */
+      this.filter = null;
+    }
+    /**
+     * Starts a filter expression.
+     *
+     * The returned builder is generic over its parent query. Call `done()` to
+     * return to this query; nested logical groups require one `done()` per group.
+     *
+     * @returns A fluent filter builder.
+     */
+    where() {
+      const clone = this.clone((newObj) => {
+        newObj.filter = new WhereQuery(newObj);
+      });
+      return clone.filter;
+    }
+    /**
+     * Specifies one or more order-by clauses.
+     *
+     * Each property may be followed by `asc` or `desc`; ascending order is the
+     * default. Property names must be simple paths without a dot.
+     *
+     * @param properties Property names and optional directions.
+     * @returns A cloned query containing the requested ordering.
+     * @throws Error If a property is not a string, contains a nested path, or
+     * has an invalid direction.
+     *
+     * @example
+     * new Query().order("Title desc", "PublicationDate asc");
+     */
+    order(...properties) {
+      properties = properties ?? [];
+      this.validatePropertyPaths(properties);
+      return this.clone((newObj) => {
+        const orderItems = [];
+        for (let i = 0; i < properties.length; i++) {
+          const member = properties[i];
+          const orderProp = new OrderProperty(member);
+          orderItems.push(orderProp);
+        }
+        newObj.orderProperties = orderItems;
+      });
+    }
+    /**
+     * Skips a number of records before returning results.
+     *
+     * @param value Number of records to skip.
+     * @returns A cloned query with `$skip` configured.
+     */
+    skip(value) {
+      return this.clone((newObj) => {
+        newObj.skipValue = value;
+      });
+    }
+    /**
+     * Limits the number of records returned.
+     *
+     * @param value Maximum number of records to return.
+     * @returns A cloned query with `$top` configured.
+     */
+    take(value) {
+      return this.clone((newObj) => {
+        newObj.takeValue = value;
+      });
+    }
+    /**
+     * Adds a full-text search expression.
+     *
+     * @param value Search text understood by the Sitefinity service.
+     * @returns A cloned query with `$search` configured.
+     */
+    search(value) {
+      return this.clone((newObj) => {
+        newObj.searchValue = value;
+      });
+    }
+    /**
+     * Requests the total matching count with the result.
+     *
+     * @param inline Whether `$count` should be enabled. Defaults to `true`.
+     * @returns A cloned query with `$count` configured.
+     */
+    count(inline = true) {
+      return this.clone((newObj) => {
+        newObj.inlineCount = inline;
+      });
+    }
+    /**
+     * Converts this query into OData query parameters.
+     *
+     * The returned object may contain `$filter`, `$select`, `$expand`,
+     * `$orderby`, `$skip`, `$top`, `$count`, and `$search`. Empty clauses are
+     * omitted. Building does not mutate the query.
+     *
+     * @returns The query parameter object for a data request.
+     */
+    build() {
+      return new QueryBuilder(this).build();
+    }
+  };
+
+  // src/Sitefinity.ts
+  var Sitefinity = class {
+    /**
+     * Creates the SDK entry point.
+     *
+     * @param options Service URL and optional site-level configuration.
+     */
+    constructor(options) {
+      this.baseUrl = options.baseUrl;
+      this.siteId = options.siteId;
+      this.factory = new RequestFactory(options);
+    }
+    /**
+     * Creates a data client for an entity set.
+     *
+     * The returned client uses the SDK defaults unless a URL, provider, culture, site,
+     * query parameters, or headers are overridden in `options`.
+     *
+     * @param options Entity-set and request URL options.
+     * @returns A data client for the requested entity set.
+     *
+     * @example
+     * const news = sdk.data({ entitySet: "newsitems", culture: "en" });
+     * news.get({ successCb: items => console.log(items) });
+     */
+    data(options) {
+      const urlOptions = {
+        baseUrl: utils.addTrailingSlash(options.baseUrl || this.baseUrl),
+        provider: options.provider,
+        culture: options.culture,
+        siteId: options.siteId || this.siteId,
+        additionalQueryParams: options.additionalQueryParams,
+        additionalHeaders: options.additionalHeaders,
+        entitySet: options.entitySet
+      };
+      return new Data(urlOptions, this.factory);
+    }
+    /**
+     * Creates a batch for grouping requests and optional upload, update, or workflow operations.
+     *
+     * Call `execute()` after adding requests. The callbacks receive the batch response,
+     * failure payload, and progress event respectively. Batch options override SDK URL options.
+     *
+     * @param success Callback invoked when the batch succeeds.
+     * @param failure Callback invoked when the batch fails.
+     * @param progress Callback invoked as request progress is reported.
+     * @param options Optional URL and request options for the batch.
+     * @returns A batch request that can be populated and executed.
+     */
+    batch(success, failure, progress, options) {
+      if (!options)
+        options = {};
+      const batch = this.factory.batch({
+        successCb: success,
+        failureCb: failure,
+        progressCb: progress,
+        urlOptions: {
+          baseUrl: utils.addTrailingSlash(options.baseUrl || this.baseUrl),
+          provider: options.provider,
+          culture: options.culture,
+          siteId: options.siteId || this.siteId,
+          additionalQueryParams: options.additionalQueryParams,
+          additionalHeaders: options.additionalHeaders
+        }
+      });
+      return batch;
+    }
+    /**
+     * Sets the value sent in the `Authorization` header.
+     *
+     * The current token form is `{ type, value }`, for example
+     * `{ type: "Bearer", value: "token" }`. A raw string is also accepted at runtime
+     * for backward compatibility and is sent unchanged.
+     *
+     * @param token Token object or legacy raw authorization header value.
+     */
+    setToken(token) {
+      this.factory.token = token;
+    }
+  };
+  /**
+   * Query builder constructor exposed for consumers that need to build OData queries.
+   */
+  Sitefinity.Query = Query;
+
+  // src/Transport/FetchTransport.ts
+  var FetchTransport = class {
+    /**
+     * Creates a fetch-based transport.
+     *
+     * @param fetchImplementation Fetch function to use. Defaults to the global `fetch`, resolved when sending.
+     */
+    constructor(fetchImplementation) {
+      this.fetchImplementation = fetchImplementation;
+    }
+    /** Sends the request with `fetch`. A failure to get any response is reported with status `0`. */
+    send(request, onComplete) {
+      const send = this.fetchImplementation ?? globalThis.fetch.bind(globalThis);
+      send(request.url, { method: request.method, headers: request.headers, body: request.body }).then((response) => response.text().then((body) => ({ response, body }))).then(
+        ({ response, body }) => onComplete({
+          status: response.status,
+          body,
+          headers: readHeaders(response.headers)
+        }),
+        () => onComplete({ status: 0, body: "", headers: {} })
+      );
+    }
+  };
+  function readHeaders(source) {
+    const headers = {};
+    source.forEach((value, name) => {
+      headers[name.toLowerCase()] = value;
+    });
+    return headers;
+  }
+  return __toCommonJS(sitefinity_webservices_sdk_exports);
+})();
+//# sourceMappingURL=sitefinity-webservices-sdk.js.map