@doist/twist-sdk 2.7.0 → 2.9.0

package/dist/esm/types/entities.js

@@ -109,8 +109,7 @@ export var WorkspaceSchema = z.object({
     plan: z.enum(WORKSPACE_PLANS).nullable().optional(),
 });
 // Channel entity from API
-export var ChannelSchema = z
-    .object({
+export var ChannelObjectSchema = z.object({
     id: z.number(),
     name: z.string(),
     description: z.string().nullable().optional(),
@@ -128,11 +127,13 @@ export var ChannelSchema = z
     icon: z.number().nullable().optional(),
     version: z.number(),
     filters: z.record(z.string(), z.string()).nullable().optional(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({ workspaceId: data.workspaceId, channelId: data.id }) })); });
+});
+export function createChannelSchema(linkBaseUrl) {
+    return ChannelObjectSchema.transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({ workspaceId: data.workspaceId, channelId: data.id }, linkBaseUrl) })); });
+}
+export var ChannelSchema = createChannelSchema();
 // Thread entity from API
-export var ThreadSchema = z
-    .object({
+export var ThreadObjectSchema = z.object({
     id: z.number(),
     title: z.string(),
     content: z.string(),
@@ -195,12 +196,15 @@ export var ThreadSchema = z
     })
         .nullable()
         .optional(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
-        workspaceId: data.workspaceId,
-        channelId: data.channelId,
-        threadId: data.id,
-    }) })); });
+});
+export function createThreadSchema(linkBaseUrl) {
+    return ThreadObjectSchema.transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
+            workspaceId: data.workspaceId,
+            channelId: data.channelId,
+            threadId: data.id,
+        }, linkBaseUrl) })); });
+}
+export var ThreadSchema = createThreadSchema();
 // Group entity from API
 export var GroupSchema = z.object({
     id: z.number(),
@@ -211,8 +215,7 @@ export var GroupSchema = z.object({
     version: z.number(),
 });
 // Conversation entity from API
-export var ConversationSchema = z
-    .object({
+export var ConversationObjectSchema = z.object({
     id: z.number(),
     workspaceId: z.number(),
     userIds: z.array(z.number()),
@@ -248,11 +251,13 @@ export var ConversationSchema = z
     })
         .nullable()
         .optional(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({ workspaceId: data.workspaceId, conversationId: data.id }) })); });
+});
+export function createConversationSchema(linkBaseUrl) {
+    return ConversationObjectSchema.transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({ workspaceId: data.workspaceId, conversationId: data.id }, linkBaseUrl) })); });
+}
+export var ConversationSchema = createConversationSchema();
 // Comment entity from API
-export var CommentSchema = z
-    .object({
+export var CommentObjectSchema = z.object({
     id: z.number(),
     content: z.string(),
     creator: z.number(),
@@ -277,13 +282,16 @@ export var CommentSchema = z
     deletedBy: z.number().nullable().optional(),
     version: z.number().nullable().optional(),
     actions: z.array(z.unknown()).nullable().optional(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
-        workspaceId: data.workspaceId,
-        channelId: data.channelId,
-        threadId: data.threadId,
-        commentId: data.id,
-    }) })); });
+});
+export function createCommentSchema(linkBaseUrl) {
+    return CommentObjectSchema.transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
+            workspaceId: data.workspaceId,
+            channelId: data.channelId,
+            threadId: data.threadId,
+            commentId: data.id,
+        }, linkBaseUrl) })); });
+}
+export var CommentSchema = createCommentSchema();
 // WorkspaceUser entity from v4 API
 export var WorkspaceUserSchema = BaseUserSchema.extend({
     email: z.string().nullable().optional(),
@@ -295,8 +303,7 @@ export var WorkspaceUserSchema = BaseUserSchema.extend({
     version: z.number(),
 });
 // ConversationMessage entity from API
-export var ConversationMessageSchema = z
-    .object({
+export var ConversationMessageObjectSchema = z.object({
     id: z.number(),
     content: z.string(),
     creator: z.number(),
@@ -313,58 +320,65 @@ export var ConversationMessageSchema = z
     directMentions: z.array(z.number()).nullable().optional(),
     version: z.number().nullable().optional(),
     workspaceId: z.number(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
-        workspaceId: data.workspaceId,
-        conversationId: data.conversationId,
-        messageId: data.id,
-    }) })); });
+});
+export function createConversationMessageSchema(linkBaseUrl) {
+    return ConversationMessageObjectSchema.transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
+            workspaceId: data.workspaceId,
+            conversationId: data.conversationId,
+            messageId: data.id,
+        }, linkBaseUrl) })); });
+}
+export var ConversationMessageSchema = createConversationMessageSchema();
 // InboxThread entity from API - returns full Thread objects with additional inbox metadata
-export var InboxThreadSchema = z
-    .object({
-    id: z.number(),
-    title: z.string(),
-    content: z.string(),
-    creator: z.number(),
-    creatorName: z.string().nullable().optional(),
-    channelId: z.number(),
-    workspaceId: z.number(),
-    actions: z.array(z.unknown()).nullable().optional(),
-    attachments: z.array(AttachmentSchema).nullable().optional(),
-    commentCount: z.number(),
-    directGroupMentions: z.array(z.number()).nullable().optional(),
-    directMentions: z.array(z.number()).nullable().optional(),
-    groups: z.array(z.number()).nullable().optional(),
-    lastEdited: z.date().nullable().optional(),
-    lastObjIndex: z.number().nullable().optional(),
-    lastUpdated: z.date(),
-    mutedUntil: z.date().nullable().optional(),
-    participants: z.array(z.number()).nullable().optional(),
-    pinned: z.boolean(),
-    pinnedDate: z.date().nullable().optional(),
-    posted: z.date(),
-    reactions: z.record(z.string(), z.array(z.number())).nullable().optional(),
-    recipients: z.array(z.number()).nullable().optional(),
-    snippet: z.string(),
-    snippetCreator: z.number(),
-    snippetMaskAvatarUrl: z.string().nullable().optional(),
-    snippetMaskPoster: z.string().nullable().optional(),
-    starred: z.boolean(),
-    systemMessage: SystemMessageSchema,
-    isArchived: z.boolean(),
-    inInbox: z.boolean(),
-    isSaved: z.boolean().nullable().optional(),
-    closed: z.boolean(),
-    responders: z.array(z.number()).nullable().optional(),
-    lastComment: CommentSchema.nullable().optional(),
-    toEmails: z.array(z.string()).nullable().optional(),
-    version: z.number().nullable().optional(),
-})
-    .transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
-        workspaceId: data.workspaceId,
-        channelId: data.channelId,
-        threadId: data.id,
-    }) })); });
+function createInboxThreadObjectSchema(linkBaseUrl) {
+    return z.object({
+        id: z.number(),
+        title: z.string(),
+        content: z.string(),
+        creator: z.number(),
+        creatorName: z.string().nullable().optional(),
+        channelId: z.number(),
+        workspaceId: z.number(),
+        actions: z.array(z.unknown()).nullable().optional(),
+        attachments: z.array(AttachmentSchema).nullable().optional(),
+        commentCount: z.number(),
+        directGroupMentions: z.array(z.number()).nullable().optional(),
+        directMentions: z.array(z.number()).nullable().optional(),
+        groups: z.array(z.number()).nullable().optional(),
+        lastEdited: z.date().nullable().optional(),
+        lastObjIndex: z.number().nullable().optional(),
+        lastUpdated: z.date(),
+        mutedUntil: z.date().nullable().optional(),
+        participants: z.array(z.number()).nullable().optional(),
+        pinned: z.boolean(),
+        pinnedDate: z.date().nullable().optional(),
+        posted: z.date(),
+        reactions: z.record(z.string(), z.array(z.number())).nullable().optional(),
+        recipients: z.array(z.number()).nullable().optional(),
+        snippet: z.string(),
+        snippetCreator: z.number(),
+        snippetMaskAvatarUrl: z.string().nullable().optional(),
+        snippetMaskPoster: z.string().nullable().optional(),
+        starred: z.boolean(),
+        systemMessage: SystemMessageSchema,
+        isArchived: z.boolean(),
+        inInbox: z.boolean(),
+        isSaved: z.boolean().nullable().optional(),
+        closed: z.boolean(),
+        responders: z.array(z.number()).nullable().optional(),
+        lastComment: createCommentSchema(linkBaseUrl).nullable().optional(),
+        toEmails: z.array(z.string()).nullable().optional(),
+        version: z.number().nullable().optional(),
+    });
+}
+export function createInboxThreadSchema(linkBaseUrl) {
+    return createInboxThreadObjectSchema(linkBaseUrl).transform(function (data) { return (__assign(__assign({}, data), { url: getFullTwistURL({
+            workspaceId: data.workspaceId,
+            channelId: data.channelId,
+            threadId: data.id,
+        }, linkBaseUrl) })); });
+}
+export var InboxThreadSchema = createInboxThreadSchema();
 // UnreadThread entity from API - simplified thread reference for unread threads
 export var UnreadThreadSchema = z.object({
     threadId: z.number(),

package/dist/esm/utils/multipart-upload.js

@@ -0,0 +1,150 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { fetchWithRetry } from '../transport/fetch-with-retry.js';
+/**
+ * Determine a content-type from a filename extension. Falls back to
+ * `application/octet-stream` for unknown extensions.
+ */
+export function getContentTypeFromFileName(fileName) {
+    var extension = fileName.toLowerCase().split('.').pop();
+    switch (extension) {
+        case 'png':
+            return 'image/png';
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'gif':
+            return 'image/gif';
+        case 'webp':
+            return 'image/webp';
+        case 'svg':
+            return 'image/svg+xml';
+        case 'pdf':
+            return 'application/pdf';
+        default:
+            return 'application/octet-stream';
+    }
+}
+/**
+ * Normalise a supported {@link UploadFile} into a `Blob` plus a resolved file name and
+ * content type, so uploads use the cross-platform global `FormData`/`Blob` body that
+ * `undici` and browsers both accept natively.
+ */
+function toBlob(file, fileName, contentType) {
+    if (file instanceof Blob) {
+        // `File` is not a global in Node 18, so guard the check before using it.
+        var name_1 = fileName ||
+            (typeof File !== 'undefined' && file instanceof File ? file.name : undefined) ||
+            'upload';
+        var type = contentType || file.type || getContentTypeFromFileName(name_1);
+        // Re-wrap only when stamping a type the Blob doesn't already carry.
+        var blob = file.type === type ? file : new Blob([file], { type: type });
+        return { blob: blob, fileName: name_1, contentType: type };
+    }
+    if (file instanceof Uint8Array) {
+        if (!fileName) {
+            throw new Error('fileName is required when uploading raw bytes');
+        }
+        var type = contentType || getContentTypeFromFileName(fileName);
+        // `Blob` accepts any `ArrayBufferView`; the cast satisfies the stricter lib
+        // `BlobPart` type (which pins the backing buffer to `ArrayBuffer`).
+        return { blob: new Blob([file], { type: type }), fileName: fileName, contentType: type };
+    }
+    throw new Error('Unsupported file type for upload: expected a Blob or Uint8Array');
+}
+/**
+ * Upload a file using `multipart/form-data`.
+ *
+ * Builds the request body with the global `FormData`/`Blob` so it works unchanged in the
+ * browser and in Node.js (via `undici`). The `file` part is sent alongside `file_name`,
+ * `file_size`, and `underlying_type` fields (the canonical Twist upload shape); any
+ * `additionalFields` are merged in and override the derived values. Authentication uses
+ * `Authorization: Bearer`, matching every other Twist SDK client, and `Content-Type` is
+ * intentionally left unset so the runtime adds the correct multipart boundary.
+ *
+ * The response is JSON-parsed and camel-cased by {@link fetchWithRetry}; callers validate
+ * the returned shape with the appropriate schema.
+ */
+export function uploadMultipartFile(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var baseUrl, authToken, endpoint, file, fileName, contentType, additionalFields, requestId, customFetch, _a, blob, resolvedFileName, resolvedType, fields, form, _i, _b, _c, key, value, headers, url, response;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    baseUrl = args.baseUrl, authToken = args.authToken, endpoint = args.endpoint, file = args.file, fileName = args.fileName, contentType = args.contentType, additionalFields = args.additionalFields, requestId = args.requestId, customFetch = args.customFetch;
+                    _a = toBlob(file, fileName, contentType), blob = _a.blob, resolvedFileName = _a.fileName, resolvedType = _a.contentType;
+                    fields = __assign({ file_name: resolvedFileName, file_size: blob.size, underlying_type: resolvedType }, additionalFields);
+                    form = new FormData();
+                    form.append('file', blob, resolvedFileName);
+                    for (_i = 0, _b = Object.entries(fields); _i < _b.length; _i++) {
+                        _c = _b[_i], key = _c[0], value = _c[1];
+                        if (value !== undefined && value !== null) {
+                            form.append(key, String(value));
+                        }
+                    }
+                    headers = {
+                        Authorization: "Bearer ".concat(authToken),
+                    };
+                    if (requestId) {
+                        headers['X-Request-Id'] = requestId;
+                    }
+                    url = new URL(endpoint, baseUrl).toString();
+                    return [4 /*yield*/, fetchWithRetry(url, {
+                            method: 'POST',
+                            headers: headers,
+                            body: form,
+                            // Don't set Content-Type — the runtime adds the multipart boundary.
+                            timeout: 30000,
+                        }, 3, customFetch)];
+                case 1:
+                    response = _d.sent();
+                    return [2 /*return*/, response.data];
+            }
+        });
+    });
+}

package/dist/types/clients/add-comment-helper.d.ts

@@ -1,11 +1,13 @@
 import type { BatchRequestDescriptor } from '../types/batch.js';
-import { type Comment } from '../types/entities.js';
+import { type Comment, type createCommentSchema } from '../types/entities.js';
 import type { CustomFetch } from '../types/http.js';
 import type { CreateCommentArgs, ThreadAction } from '../types/requests.js';
 type ClientContext = {
     baseUri: string;
     apiToken: string;
     customFetch?: CustomFetch;
+    /** Per-client Comment schema, base-bound for the returned comment's web `url`. */
+    schema: ReturnType<typeof createCommentSchema>;
 };
 export declare function addCommentRequest(context: ClientContext, params: CreateCommentArgs, options?: {
     batch?: boolean;

package/dist/types/clients/attachments-client.d.ts

@@ -0,0 +1,39 @@
+import { type Attachment } from '../types/entities.js';
+import type { UploadAttachmentArgs } from '../types/requests.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Client for uploading file attachments to Twist.
+ *
+ * Attachments are uploaded independently, then referenced by passing the returned
+ * {@link Attachment} into the `attachments` array of `comments.createComment`,
+ * `conversationMessages.createMessage`, and similar calls.
+ */
+export declare class AttachmentsClient extends BaseClient {
+    /**
+     * Uploads a file and returns the created {@link Attachment}.
+     *
+     * Mirrors the canonical multipart upload used by twist-web: `POST /attachments/upload`
+     * with the `file` binary plus `file_name`, `file_size`, `attachment_id`, and
+     * `underlying_type` form fields.
+     *
+     * @param args - The file to upload and optional metadata.
+     * @returns The created attachment, ready to attach to a comment or message.
+     *
+     * @example
+     * ```typescript
+     * import { readFile } from 'node:fs/promises'
+     *
+     * const attachment = await api.attachments.upload({
+     *   file: await readFile('./diagram.png'),
+     *   fileName: 'diagram.png',
+     * })
+     *
+     * await api.comments.createComment({
+     *   threadId: 789,
+     *   content: 'See attached',
+     *   attachments: [attachment],
+     * })
+     * ```
+     */
+    upload(args: UploadAttachmentArgs): Promise<Attachment>;
+}

package/dist/types/clients/base-client.d.ts

@@ -28,4 +28,8 @@ export declare class BaseClient {
      * @returns Base URI with guaranteed trailing slash for proper URL resolution
      */
     protected getBaseUri(version?: ApiVersion): string;
+    /**
+     * Base URL for entity web links, or `undefined` to use getFullTwistURL's default web app.
+     */
+    protected getLinkBaseUrl(): string | undefined;
 }

package/dist/types/clients/channels-client.d.ts

@@ -6,6 +6,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist channel endpoints.
  */
 export declare class ChannelsClient extends BaseClient {
+    private readonly channelSchema;
     /**
      * Gets all channels for a given workspace.
      *

package/dist/types/clients/comments-client.d.ts

@@ -6,6 +6,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist comment endpoints.
  */
 export declare class CommentsClient extends BaseClient {
+    private readonly commentSchema;
     /**
      * Gets all comments for a thread.
      *

package/dist/types/clients/conversation-messages-client.d.ts

@@ -6,6 +6,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist conversation message endpoints.
  */
 export declare class ConversationMessagesClient extends BaseClient {
+    private readonly messageSchema;
     /**
      * Gets all messages in a conversation.
      *

package/dist/types/clients/conversations-client.d.ts

@@ -6,6 +6,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist conversation endpoints.
  */
 export declare class ConversationsClient extends BaseClient {
+    private readonly conversationSchema;
     /**
      * Gets all conversations for a workspace.
      *

package/dist/types/clients/inbox-client.d.ts

@@ -6,6 +6,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist inbox endpoints.
  */
 export declare class InboxClient extends BaseClient {
+    private readonly inboxThreadSchema;
     /**
      * Gets inbox items (threads).
      *

package/dist/types/clients/threads-client.d.ts

@@ -6,6 +6,8 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist thread endpoints.
  */
 export declare class ThreadsClient extends BaseClient {
+    private readonly threadSchema;
+    private readonly commentSchema;
     /**
      * Gets all threads in a channel.
      *

package/dist/types/clients/workspace-users-client.d.ts

@@ -10,9 +10,14 @@ export declare class WorkspaceUsersClient extends BaseClient {
     /**
      * Returns a list of workspace user objects for the given workspace id.
      *
+     * Removed users are excluded by default; set `args.includeRemoved` to `true` to include them.
+     * The Twist API always returns removed users, so the filtering happens client-side (in both the
+     * awaited and batch modes).
+     *
      * @param args - The arguments for getting workspace users.
      * @param args.workspaceId - The workspace ID.
      * @param args.archived - Optional flag to filter archived users.
+     * @param args.includeRemoved - Include users removed from the workspace. Defaults to `false`.
      * @param options - Optional configuration. Set `batch: true` to return a descriptor for batch requests.
      * @returns An array of workspace user objects.
      *

package/dist/types/clients/workspaces-client.d.ts

@@ -5,6 +5,7 @@ import { BaseClient } from './base-client.js';
  * Client for interacting with Twist workspace endpoints.
  */
 export declare class WorkspacesClient extends BaseClient {
+    private readonly channelSchema;
     /**
      * Gets all the user's workspaces.
      *

package/dist/types/consts/endpoints.d.ts

@@ -24,3 +24,4 @@ export declare const ENDPOINT_INBOX = "inbox";
 export declare const ENDPOINT_REACTIONS = "reactions";
 export declare const ENDPOINT_SEARCH = "search";
 export declare const ENDPOINT_CONVERSATION_MESSAGES = "conversation_messages";
+export declare const ENDPOINT_ATTACHMENTS = "attachments";

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from './authentication.js';
 export { BatchBuilder } from './batch-builder.js';
+export { AttachmentsClient } from './clients/attachments-client.js';
 export { ConversationMessagesClient } from './clients/conversation-messages-client.js';
 export { InboxClient } from './clients/inbox-client.js';
 export { ReactionsClient } from './clients/reactions-client.js';

package/dist/types/twist-api.d.ts

@@ -1,3 +1,4 @@
+import { AttachmentsClient } from './clients/attachments-client.js';
 import { ChannelsClient } from './clients/channels-client.js';
 import { CommentsClient } from './clients/comments-client.js';
 import { ConversationMessagesClient } from './clients/conversation-messages-client.js';
@@ -42,6 +43,7 @@ export declare class TwistApi {
     inbox: InboxClient;
     reactions: ReactionsClient;
     search: SearchClient;
+    attachments: AttachmentsClient;
     private authToken;
     private baseUrl?;
     private customFetch?;