@tablestore/tablestore-agent-cli 0.3.1 → 0.4.0

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/auth/sign-v2.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignV2 = void 0;
+const sign_base_js_1 = require("./sign-base.js");
+class SignV2 extends sign_base_js_1.SignBase {
+    getSigningKey(requestContext) {
+        return requestContext.getCredentials().accessKeySecret;
+    }
+    makeRequestSignatureAndAddHeaders(query, headers, requestContext) {
+        headers['x-ots-signature'] = (0, sign_base_js_1.hmacSha1Base64)(this.getSigningKey(requestContext), this.getRequestSignatureString(query, headers));
+    }
+}
+exports.SignV2 = SignV2;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/auth/sign-v4.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignV4 = void 0;
+const node_crypto_1 = require("node:crypto");
+const client_error_js_1 = require("../errors/client-error.js");
+const sign_base_js_1 = require("./sign-base.js");
+const V4_SIGNATURE_PRODUCT = 'ots';
+const V4_SIGNATURE_SEED = 'aliyun';
+const V4_SIGNATURE_PREFIX = `${V4_SIGNATURE_SEED}_v4`;
+const V4_SIGNATURE_CONSTANT = `${V4_SIGNATURE_SEED}_v4_request`;
+const V4_SIGNATURE_SALT = 'ots';
+function hmacSha256Bytes(signingKey, content) {
+    return (0, node_crypto_1.createHmac)('sha256', signingKey).update(content, 'utf8').digest();
+}
+class SignV4 extends sign_base_js_1.SignBase {
+    signRegion;
+    signDate;
+    autoUpdateV4Sign;
+    constructor(options) {
+        super();
+        if (!options.region) {
+            throw new client_error_js_1.OTSClientError('region is not str or is empty.');
+        }
+        this.signRegion = options.region;
+        this.signDate = options.signDate;
+        this.autoUpdateV4Sign = options.autoUpdateV4Sign ?? options.signDate === undefined;
+    }
+    getAndSetV4SignDate(requestContext) {
+        const currentDate = this.autoUpdateV4Sign
+            ? new Date().toISOString().slice(0, 10).replaceAll('-', '')
+            : this.signDate;
+        const signDate = this.requireSignDate(currentDate);
+        requestContext.setSignDate(signDate);
+        return signDate;
+    }
+    getSigningKey(requestContext) {
+        const accessKeySecret = requestContext.getCredentials().accessKeySecret;
+        const signDate = this.requireSignDate(requestContext.getSignDate());
+        const first = hmacSha256Bytes(`${V4_SIGNATURE_PREFIX}${accessKeySecret}`, signDate);
+        const second = hmacSha256Bytes(first, this.signRegion);
+        const third = hmacSha256Bytes(second, V4_SIGNATURE_PRODUCT);
+        const fourth = hmacSha256Bytes(third, V4_SIGNATURE_CONSTANT);
+        return Buffer.from(fourth.toString('base64'), 'utf8');
+    }
+    makeRequestSignatureAndAddHeaders(query, headers, requestContext) {
+        headers['x-ots-signdate'] = this.getAndSetV4SignDate(requestContext);
+        headers['x-ots-signregion'] = this.signRegion;
+        headers['x-ots-signaturev4'] = (0, sign_base_js_1.hmacSha256Base64)(this.getSigningKey(requestContext), `${this.getRequestSignatureString(query, headers)}${V4_SIGNATURE_SALT}`);
+    }
+}
+exports.SignV4 = SignV4;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/client/agent-storage-client.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStorageClient = void 0;
+const ots_json_client_js_1 = require("../http/ots-json-client.js");
+const version_js_1 = require("../version.js");
+const file_js_1 = require("../models/file.js");
+const to_json_request_js_1 = require("../serialization/to-json-request.js");
+/**
+ * Normalizes an item request body, filling `type: 'memoryfile'` when the
+ * caller did not provide a non-empty item type.
+ */
+function toItemRequest(request) {
+    const body = ((0, to_json_request_js_1.toJSONRequest)(request ?? {}) ?? {});
+    if (typeof body.type === 'string' && body.type.length > 0) {
+        return body;
+    }
+    const { type: _omitted, ...rest } = body;
+    return { type: file_js_1.ITEM_TYPE_MEMORY_FILE, ...rest };
+}
+class AgentStorageClient {
+    client;
+    constructor(options) {
+        const fetchImpl = options.fetch ?? globalThis.fetch;
+        const userAgent = options.userAgentSuffix
+            ? `${version_js_1.DEFAULT_USER_AGENT} ${options.userAgentSuffix}`
+            : version_js_1.DEFAULT_USER_AGENT;
+        this.client = new ots_json_client_js_1.OTSJSONClient({
+            endpoint: options.endpoint,
+            instanceName: options.instanceName,
+            credentials: options.accessKeyId && options.accessKeySecret
+                ? {
+                    accessKeyId: options.accessKeyId,
+                    accessKeySecret: options.accessKeySecret,
+                    securityToken: options.stsToken,
+                }
+                : undefined,
+            apiKey: options.apiKey,
+            signVersion: options.signVersion ?? 'v2',
+            region: options.region,
+            fetch: fetchImpl,
+            userAgent,
+            extraHeaders: options.extraHeaders,
+        });
+    }
+    createKnowledgeBase(request) {
+        return this.client.request('CreateKnowledgeBase', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    deleteKnowledgeBase(request) {
+        return this.client.request('DeleteKnowledgeBase', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    describeKnowledgeBase(request) {
+        return this.client.request('DescribeKnowledgeBase', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listKnowledgeBase(request = {}) {
+        return this.client.request('ListKnowledgeBase', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateKnowledgeBase(request) {
+        return this.client.request('UpdateKnowledgeBase', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    addDocuments(request) {
+        return this.client.request('AddDocuments', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateDocument(request) {
+        return this.client.request('UpdateDocument', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getDocument(request) {
+        return this.client.request('GetDocument', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listDocuments(request) {
+        return this.client.request('ListDocuments', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    deleteDocuments(request) {
+        return this.client.request('DeleteDocuments', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    retrieve(request) {
+        return this.client.request('Retrieve', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listChunks(request) {
+        return this.client.request('ListChunks', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateChunks(request) {
+        return this.client.request('UpdateChunks', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    createMemoryStore(request) {
+        return this.client.request('CreateMemoryStore', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getMemoryStore(request) {
+        return this.client.request('GetMemoryStore', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryStores(request = {}) {
+        return this.client.request('ListMemoryStores', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateMemoryStore(request) {
+        return this.client.request('UpdateMemoryStore', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    deleteMemoryStore(request) {
+        return this.client.request('DeleteMemoryStore', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    addMemories(request) {
+        return this.client.request('AddMemories', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    searchMemories(request) {
+        return this.client.request('SearchMemories', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemories(request) {
+        return this.client.request('ListMemories', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getMemory(request) {
+        return this.client.request('GetMemory', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateMemory(request) {
+        return this.client.request('UpdateMemory', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    deleteMemory(request) {
+        return this.client.request('DeleteMemory', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryStoreMessages(request) {
+        return this.client.request('ListMemoryStoreMessages', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryStoreRequests(request) {
+        return this.client.request('ListMemoryStoreRequests', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getMemoryTask(request) {
+        return this.client.request('GetMemoryTask', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryTasks(request) {
+        return this.client.request('ListMemoryTasks', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryStoreScopes(request) {
+        return this.client.request('ListMemoryStoreScopes', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    createMemoryDreamTask(request) {
+        return this.client.request('CreateMemoryDreamTask', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getMemoryDreamTask(request) {
+        return this.client.request('GetMemoryDreamTask', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryDreamTasks(request) {
+        return this.client.request('ListMemoryDreamTasks', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    cancelMemoryDreamTask(request) {
+        return this.client.request('CancelMemoryDreamTask', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listMemoryDreamActions(request) {
+        return this.client.request('ListMemoryDreamActions', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    applyMemoryDreamActions(request) {
+        return this.client.request('ApplyMemoryDreamActions', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getWiki(request) {
+        return this.client.request('GetWiki', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    updateWiki(request) {
+        return this.client.request('UpdateWiki', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    ingestWiki(request) {
+        return this.client.request('IngestWiki', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    listWikiPages(request) {
+        return this.client.request('ListWikiPages', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    getWikiPage(request) {
+        return this.client.request('GetWikiPage', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    searchWikiPages(request) {
+        return this.client.request('SearchWikiPages', (0, to_json_request_js_1.toJSONRequest)(request));
+    }
+    addItem(request) {
+        return this.client.request('AddItem', toItemRequest(request));
+    }
+    listItems(request) {
+        return this.client.request('ListItems', toItemRequest(request));
+    }
+    getItem(request) {
+        return this.client.request('GetItem', toItemRequest(request));
+    }
+    updateItem(request) {
+        return this.client.request('UpdateItem', toItemRequest(request));
+    }
+    deleteItem(request) {
+        return this.client.request('DeleteItem', toItemRequest(request));
+    }
+    listItemVersions(request) {
+        return this.client.request('ListItemVersions', toItemRequest(request));
+    }
+    getItemVersion(request) {
+        return this.client.request('GetItemVersion', toItemRequest(request));
+    }
+    redactItemVersion(request) {
+        return this.client.request('RedactItemVersion', toItemRequest(request));
+    }
+    uploadDocuments(_request) {
+        throw new Error('uploadDocuments is only available in the NodeAgentStorageClient.');
+    }
+}
+exports.AgentStorageClient = AgentStorageClient;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/errors/client-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTSClientError = void 0;
+class OTSClientError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'OTSClientError';
+    }
+}
+exports.OTSClientError = OTSClientError;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/errors/service-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTSServiceError = void 0;
+class OTSServiceError extends Error {
+    statusCode;
+    requestId;
+    code;
+    constructor(message, options) {
+        super(message);
+        this.name = 'OTSServiceError';
+        this.statusCode = options.statusCode;
+        this.requestId = options.requestId;
+        this.code = options.code;
+    }
+}
+exports.OTSServiceError = OTSServiceError;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/http/headers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDateHeader = buildDateHeader;
+exports.buildRequestHeaders = buildRequestHeaders;
+const md5_js_1 = require("./md5.js");
+const version_js_1 = require("../version.js");
+const API_VERSION = '2015-12-31';
+function buildDateHeader(date = new Date()) {
+    const iso = date.toISOString();
+    return `${iso.slice(0, 19)}.000Z`;
+}
+function buildRequestHeaders(options) {
+    const headers = {
+        'x-ots-date': buildDateHeader(options.date),
+        'x-ots-apiversion': API_VERSION,
+        'x-ots-accesskeyid': options.credentials.accessKeyId,
+        'x-ots-instancename': options.instanceName,
+        'x-ots-contentmd5': (0, md5_js_1.md5Base64)(options.body),
+    };
+    if (options.credentials.securityToken) {
+        headers['x-ots-ststoken'] = options.credentials.securityToken;
+    }
+    if (options.extraHeaders) {
+        for (const [key, value] of Object.entries(options.extraHeaders)) {
+            headers[key] = value;
+        }
+    }
+    options.signer.makeRequestSignatureAndAddHeaders(options.query, headers, options.requestContext);
+    headers['User-Agent'] = options.userAgent ?? version_js_1.DEFAULT_USER_AGENT;
+    return headers;
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/http/md5.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.md5Base64 = md5Base64;
+const node_crypto_1 = require("node:crypto");
+function md5Base64(content) {
+    const hash = (0, node_crypto_1.createHash)('md5');
+    hash.update(content);
+    return hash.digest('base64');
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/http/ots-json-client.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTSJSONClient = void 0;
+const client_error_js_1 = require("../errors/client-error.js");
+const service_error_js_1 = require("../errors/service-error.js");
+const sign_v2_js_1 = require("../auth/sign-v2.js");
+const sign_v4_js_1 = require("../auth/sign-v4.js");
+const headers_js_1 = require("./headers.js");
+const md5_js_1 = require("./md5.js");
+const request_context_js_1 = require("../auth/request-context.js");
+const version_js_1 = require("../version.js");
+function normalizeHeaders(headers) {
+    const normalized = {};
+    headers.forEach((value, key) => {
+        normalized[key.toLowerCase()] = value;
+    });
+    return normalized;
+}
+class OTSJSONClient {
+    endpoint;
+    instanceName;
+    credentials;
+    apiKey;
+    fetchImpl;
+    signer;
+    userAgent;
+    extraHeaders;
+    constructor(options) {
+        if (!options.credentials && !options.apiKey) {
+            throw new client_error_js_1.OTSClientError('Either credentials (accessKeyId/accessKeySecret) or apiKey must be provided.');
+        }
+        if (options.apiKey && !options.endpoint.startsWith('https://')) {
+            throw new client_error_js_1.OTSClientError('API key authentication requires HTTPS. Endpoint must start with https://.');
+        }
+        this.endpoint = options.endpoint.replace(/\/+$/, '');
+        this.instanceName = options.instanceName;
+        this.credentials = options.credentials;
+        this.apiKey = options.apiKey;
+        this.fetchImpl = options.fetch;
+        this.userAgent = options.userAgent ?? version_js_1.DEFAULT_USER_AGENT;
+        this.extraHeaders = options.extraHeaders;
+        if (options.credentials) {
+            this.signer =
+                (options.signVersion ?? 'v2') === 'v4'
+                    ? new sign_v4_js_1.SignV4({ region: options.region })
+                    : new sign_v2_js_1.SignV2();
+        }
+    }
+    buildHeaders(action, body) {
+        let headers;
+        let requestContext;
+        if (this.apiKey) {
+            headers = {
+                'x-ots-instancename': this.instanceName,
+                'x-ots-apikey': this.apiKey,
+                'Content-Type': 'application/json',
+                'User-Agent': this.userAgent,
+            };
+            if (this.extraHeaders) {
+                for (const [key, value] of Object.entries(this.extraHeaders)) {
+                    headers[key] = value;
+                }
+            }
+        }
+        else {
+            requestContext = new request_context_js_1.RequestContext(this.credentials);
+            headers = (0, headers_js_1.buildRequestHeaders)({
+                body: new TextEncoder().encode(body),
+                query: `/${action}`,
+                instanceName: this.instanceName,
+                credentials: this.credentials,
+                signer: this.signer,
+                requestContext,
+                userAgent: this.userAgent,
+                extraHeaders: this.extraHeaders,
+            });
+            headers['Content-Type'] = 'application/json';
+        }
+        return { headers, requestContext };
+    }
+    async request(action, payload) {
+        if (!this.fetchImpl) {
+            throw new client_error_js_1.OTSClientError('fetch implementation is required.');
+        }
+        const body = JSON.stringify(payload);
+        const { headers, requestContext } = this.buildHeaders(action, body);
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.endpoint}/${action}`, {
+                method: 'POST',
+                headers,
+                body,
+            });
+        }
+        catch (error) {
+            throw new client_error_js_1.OTSClientError(`Failed to send request: ${String(error)}`);
+        }
+        const responseText = await response.text();
+        const responseBytes = new TextEncoder().encode(responseText);
+        const responseHeaders = normalizeHeaders(response.headers);
+        if (!this.apiKey) {
+            this.validateResponseHeaders(responseHeaders, responseBytes, response.status, requestContext, `/${action}`);
+        }
+        if (!response.ok) {
+            let errorPayload = {};
+            try {
+                errorPayload = responseText ? JSON.parse(responseText) : {};
+            }
+            catch {
+                errorPayload = {};
+            }
+            throw new service_error_js_1.OTSServiceError(String(errorPayload.message ?? response.statusText), {
+                statusCode: response.status,
+                requestId: responseHeaders['x-ots-requestid'],
+                code: typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
+            });
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new client_error_js_1.OTSClientError(`Failed to parse JSON response: ${String(error)}`);
+        }
+    }
+    validateResponseHeaders(headers, body, status, requestContext, query) {
+        if (status >= 200 && status < 300) {
+            for (const header of ['x-ots-contentmd5', 'x-ots-requestid', 'x-ots-date', 'x-ots-contenttype']) {
+                if (!(header in headers)) {
+                    throw new client_error_js_1.OTSClientError(`"${header}" is missing in response header.`);
+                }
+            }
+        }
+        if (headers['x-ots-contentmd5'] && (0, md5_js_1.md5Base64)(body) !== headers['x-ots-contentmd5']) {
+            throw new client_error_js_1.OTSClientError('MD5 mismatch in response.');
+        }
+        const authorization = headers.authorization;
+        if (!authorization) {
+            if (status >= 200 && status < 300) {
+                throw new client_error_js_1.OTSClientError('"Authorization" is missing in response header.');
+            }
+            return;
+        }
+        if (!authorization.startsWith('OTS ')) {
+            throw new client_error_js_1.OTSClientError('Invalid Authorization in response.');
+        }
+        const [accessKeyId, signature] = authorization.slice(4).split(':');
+        if (accessKeyId !== this.credentials.accessKeyId) {
+            throw new client_error_js_1.OTSClientError('Invalid access key id in response.');
+        }
+        if (signature !== this.signer.makeResponseSignature(query, headers, this.signer.getSigningKey(requestContext))) {
+            throw new client_error_js_1.OTSClientError('Invalid signature in response.');
+        }
+    }
+}
+exports.OTSJSONClient = OTSJSONClient;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/models/base.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignIfPresent = assignIfPresent;
+exports.toJsonValue = toJsonValue;
+const unset_js_1 = require("./unset.js");
+function assignIfPresent(target, key, value) {
+    if (!(0, unset_js_1.isUnset)(value)) {
+        target[key] = value;
+    }
+}
+function toJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonValue(item));
+    }
+    if (value && typeof value === 'object' && 'toJSONRequest' in value && typeof value.toJSONRequest === 'function') {
+        return value.toJSONRequest();
+    }
+    return value;
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/cjs/src/core/models/chunk.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListChunksRequest = exports.UpdateChunksRequest = exports.UpdateChunkItem = void 0;
+const base_js_1 = require("./base.js");
+class UpdateChunkItem {
+    chunkId;
+    docId;
+    ossKey;
+    title;
+    content;
+    status;
+    constructor(options) {
+        Object.assign(this, options);
+        this.chunkId = options.chunkId;
+    }
+    toJSONRequest() {
+        const result = { chunkId: this.chunkId };
+        (0, base_js_1.assignIfPresent)(result, 'docId', this.docId);
+        (0, base_js_1.assignIfPresent)(result, 'ossKey', this.ossKey);
+        (0, base_js_1.assignIfPresent)(result, 'title', this.title);
+        (0, base_js_1.assignIfPresent)(result, 'content', this.content);
+        (0, base_js_1.assignIfPresent)(result, 'status', this.status);
+        return result;
+    }
+}
+exports.UpdateChunkItem = UpdateChunkItem;
+class UpdateChunksRequest {
+    knowledgeBaseName;
+    chunks;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+        this.chunks = options.chunks;
+    }
+    toJSONRequest() {
+        const result = {
+            knowledgeBaseName: this.knowledgeBaseName,
+            chunks: this.chunks.map((item) => item.toJSONRequest()),
+        };
+        (0, base_js_1.assignIfPresent)(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+exports.UpdateChunksRequest = UpdateChunksRequest;
+class ListChunksRequest {
+    knowledgeBaseName;
+    subspace;
+    docId;
+    ossKey;
+    maxResults;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+    }
+    toJSONRequest() {
+        const result = { knowledgeBaseName: this.knowledgeBaseName };
+        (0, base_js_1.assignIfPresent)(result, 'subspace', this.subspace);
+        (0, base_js_1.assignIfPresent)(result, 'docId', this.docId);
+        (0, base_js_1.assignIfPresent)(result, 'ossKey', this.ossKey);
+        (0, base_js_1.assignIfPresent)(result, 'maxResults', this.maxResults);
+        (0, base_js_1.assignIfPresent)(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+exports.ListChunksRequest = ListChunksRequest;