@elumixor/notion-orm 0.1.1

package/dist/index.js

@@ -0,0 +1,1803 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/@notionhq/client/build/src/utils.js
+var require_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.assertNever = assertNever;
+  exports.pick = pick;
+  exports.isObject = isObject;
+  function assertNever(value) {
+    throw new Error(`Unexpected value should never occur: ${value}`);
+  }
+  function pick(base, keys) {
+    const entries = keys.map((key) => [key, base === null || base === undefined ? undefined : base[key]]);
+    return Object.fromEntries(entries);
+  }
+  function isObject(o) {
+    return typeof o === "object" && o !== null;
+  }
+});
+
+// node_modules/@notionhq/client/build/src/logging.js
+var require_logging = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LogLevel = undefined;
+  exports.makeConsoleLogger = makeConsoleLogger;
+  exports.logLevelSeverity = logLevelSeverity;
+  var utils_1 = require_utils();
+  var LogLevel;
+  (function(LogLevel2) {
+    LogLevel2["DEBUG"] = "debug";
+    LogLevel2["INFO"] = "info";
+    LogLevel2["WARN"] = "warn";
+    LogLevel2["ERROR"] = "error";
+  })(LogLevel || (exports.LogLevel = LogLevel = {}));
+  function makeConsoleLogger(name) {
+    return (level, message, extraInfo) => {
+      console[level](`${name} ${level}:`, message, extraInfo);
+    };
+  }
+  function logLevelSeverity(level) {
+    switch (level) {
+      case LogLevel.DEBUG:
+        return 20;
+      case LogLevel.INFO:
+        return 40;
+      case LogLevel.WARN:
+        return 60;
+      case LogLevel.ERROR:
+        return 80;
+      default:
+        return (0, utils_1.assertNever)(level);
+    }
+  }
+});
+
+// node_modules/@notionhq/client/build/src/errors.js
+var require_errors = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.APIResponseError = exports.UnknownHTTPResponseError = exports.RequestTimeoutError = exports.ClientErrorCode = exports.APIErrorCode = undefined;
+  exports.isNotionClientError = isNotionClientError;
+  exports.isHTTPResponseError = isHTTPResponseError;
+  exports.buildRequestError = buildRequestError;
+  var utils_1 = require_utils();
+  var APIErrorCode;
+  (function(APIErrorCode2) {
+    APIErrorCode2["Unauthorized"] = "unauthorized";
+    APIErrorCode2["RestrictedResource"] = "restricted_resource";
+    APIErrorCode2["ObjectNotFound"] = "object_not_found";
+    APIErrorCode2["RateLimited"] = "rate_limited";
+    APIErrorCode2["InvalidJSON"] = "invalid_json";
+    APIErrorCode2["InvalidRequestURL"] = "invalid_request_url";
+    APIErrorCode2["InvalidRequest"] = "invalid_request";
+    APIErrorCode2["ValidationError"] = "validation_error";
+    APIErrorCode2["ConflictError"] = "conflict_error";
+    APIErrorCode2["InternalServerError"] = "internal_server_error";
+    APIErrorCode2["ServiceUnavailable"] = "service_unavailable";
+  })(APIErrorCode || (exports.APIErrorCode = APIErrorCode = {}));
+  var ClientErrorCode;
+  (function(ClientErrorCode2) {
+    ClientErrorCode2["RequestTimeout"] = "notionhq_client_request_timeout";
+    ClientErrorCode2["ResponseError"] = "notionhq_client_response_error";
+  })(ClientErrorCode || (exports.ClientErrorCode = ClientErrorCode = {}));
+
+  class NotionClientErrorBase extends Error {
+  }
+  function isNotionClientError(error) {
+    return (0, utils_1.isObject)(error) && error instanceof NotionClientErrorBase;
+  }
+  function isNotionClientErrorWithCode(error, codes) {
+    return isNotionClientError(error) && error.code in codes;
+  }
+
+  class RequestTimeoutError extends NotionClientErrorBase {
+    constructor(message = "Request to Notion API has timed out") {
+      super(message);
+      this.code = ClientErrorCode.RequestTimeout;
+      this.name = "RequestTimeoutError";
+    }
+    static isRequestTimeoutError(error) {
+      return isNotionClientErrorWithCode(error, {
+        [ClientErrorCode.RequestTimeout]: true
+      });
+    }
+    static rejectAfterTimeout(promise, timeoutMS) {
+      return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new RequestTimeoutError);
+        }, timeoutMS);
+        promise.then(resolve).catch(reject).then(() => clearTimeout(timeoutId));
+      });
+    }
+  }
+  exports.RequestTimeoutError = RequestTimeoutError;
+
+  class HTTPResponseError extends NotionClientErrorBase {
+    constructor(args) {
+      super(args.message);
+      this.name = "HTTPResponseError";
+      const { code, status, headers, rawBodyText, additional_data, request_id } = args;
+      this.code = code;
+      this.status = status;
+      this.headers = headers;
+      this.body = rawBodyText;
+      this.additional_data = additional_data;
+      this.request_id = request_id;
+    }
+  }
+  var httpResponseErrorCodes = {
+    [ClientErrorCode.ResponseError]: true,
+    [APIErrorCode.Unauthorized]: true,
+    [APIErrorCode.RestrictedResource]: true,
+    [APIErrorCode.ObjectNotFound]: true,
+    [APIErrorCode.RateLimited]: true,
+    [APIErrorCode.InvalidJSON]: true,
+    [APIErrorCode.InvalidRequestURL]: true,
+    [APIErrorCode.InvalidRequest]: true,
+    [APIErrorCode.ValidationError]: true,
+    [APIErrorCode.ConflictError]: true,
+    [APIErrorCode.InternalServerError]: true,
+    [APIErrorCode.ServiceUnavailable]: true
+  };
+  function isHTTPResponseError(error) {
+    if (!isNotionClientErrorWithCode(error, httpResponseErrorCodes)) {
+      return false;
+    }
+    return true;
+  }
+
+  class UnknownHTTPResponseError extends HTTPResponseError {
+    constructor(args) {
+      var _a;
+      super({
+        ...args,
+        code: ClientErrorCode.ResponseError,
+        message: (_a = args.message) !== null && _a !== undefined ? _a : `Request to Notion API failed with status: ${args.status}`,
+        additional_data: undefined,
+        request_id: undefined
+      });
+      this.name = "UnknownHTTPResponseError";
+    }
+    static isUnknownHTTPResponseError(error) {
+      return isNotionClientErrorWithCode(error, {
+        [ClientErrorCode.ResponseError]: true
+      });
+    }
+  }
+  exports.UnknownHTTPResponseError = UnknownHTTPResponseError;
+  var apiErrorCodes = {
+    [APIErrorCode.Unauthorized]: true,
+    [APIErrorCode.RestrictedResource]: true,
+    [APIErrorCode.ObjectNotFound]: true,
+    [APIErrorCode.RateLimited]: true,
+    [APIErrorCode.InvalidJSON]: true,
+    [APIErrorCode.InvalidRequestURL]: true,
+    [APIErrorCode.InvalidRequest]: true,
+    [APIErrorCode.ValidationError]: true,
+    [APIErrorCode.ConflictError]: true,
+    [APIErrorCode.InternalServerError]: true,
+    [APIErrorCode.ServiceUnavailable]: true
+  };
+
+  class APIResponseError extends HTTPResponseError {
+    constructor() {
+      super(...arguments);
+      this.name = "APIResponseError";
+    }
+    static isAPIResponseError(error) {
+      return isNotionClientErrorWithCode(error, apiErrorCodes);
+    }
+  }
+  exports.APIResponseError = APIResponseError;
+  function buildRequestError(response, bodyText) {
+    const apiErrorResponseBody = parseAPIErrorResponseBody(bodyText);
+    if (apiErrorResponseBody !== undefined) {
+      return new APIResponseError({
+        code: apiErrorResponseBody.code,
+        message: apiErrorResponseBody.message,
+        headers: response.headers,
+        status: response.status,
+        rawBodyText: bodyText,
+        additional_data: apiErrorResponseBody.additional_data,
+        request_id: apiErrorResponseBody.request_id
+      });
+    }
+    return new UnknownHTTPResponseError({
+      message: undefined,
+      headers: response.headers,
+      status: response.status,
+      rawBodyText: bodyText
+    });
+  }
+  function parseAPIErrorResponseBody(body) {
+    if (typeof body !== "string") {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch (parseError) {
+      return;
+    }
+    if (!(0, utils_1.isObject)(parsed) || typeof parsed["message"] !== "string" || !isAPIErrorCode(parsed["code"])) {
+      return;
+    }
+    const additional_data = parsed["additional_data"];
+    const request_id = parsed["request_id"];
+    return {
+      ...parsed,
+      code: parsed["code"],
+      message: parsed["message"],
+      additional_data,
+      request_id
+    };
+  }
+  function isAPIErrorCode(code) {
+    return typeof code === "string" && code in apiErrorCodes;
+  }
+});
+
+// node_modules/@notionhq/client/build/src/api-endpoints.js
+var require_api_endpoints = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.listDataSourceTemplates = exports.oauthIntrospect = exports.oauthRevoke = exports.oauthToken = exports.getFileUpload = exports.completeFileUpload = exports.sendFileUpload = exports.listFileUploads = exports.createFileUpload = exports.getComment = exports.listComments = exports.createComment = exports.search = exports.createDatabase = exports.updateDatabase = exports.getDatabase = exports.createDataSource = exports.queryDataSource = exports.updateDataSource = exports.getDataSource = exports.appendBlockChildren = exports.listBlockChildren = exports.deleteBlock = exports.updateBlock = exports.getBlock = exports.getPageProperty = exports.updatePage = exports.getPage = exports.createPage = exports.listUsers = exports.getUser = exports.getSelf = undefined;
+  exports.getSelf = {
+    method: "get",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [],
+    path: () => `users/me`
+  };
+  exports.getUser = {
+    method: "get",
+    pathParams: ["user_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `users/${p.user_id}`
+  };
+  exports.listUsers = {
+    method: "get",
+    pathParams: [],
+    queryParams: ["start_cursor", "page_size"],
+    bodyParams: [],
+    path: () => `users`
+  };
+  exports.createPage = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [
+      "parent",
+      "properties",
+      "icon",
+      "cover",
+      "content",
+      "children",
+      "template"
+    ],
+    path: () => `pages`
+  };
+  exports.getPage = {
+    method: "get",
+    pathParams: ["page_id"],
+    queryParams: ["filter_properties"],
+    bodyParams: [],
+    path: (p) => `pages/${p.page_id}`
+  };
+  exports.updatePage = {
+    method: "patch",
+    pathParams: ["page_id"],
+    queryParams: [],
+    bodyParams: [
+      "properties",
+      "icon",
+      "cover",
+      "is_locked",
+      "template",
+      "erase_content",
+      "archived",
+      "in_trash"
+    ],
+    path: (p) => `pages/${p.page_id}`
+  };
+  exports.getPageProperty = {
+    method: "get",
+    pathParams: ["page_id", "property_id"],
+    queryParams: ["start_cursor", "page_size"],
+    bodyParams: [],
+    path: (p) => `pages/${p.page_id}/properties/${p.property_id}`
+  };
+  exports.getBlock = {
+    method: "get",
+    pathParams: ["block_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `blocks/${p.block_id}`
+  };
+  exports.updateBlock = {
+    method: "patch",
+    pathParams: ["block_id"],
+    queryParams: [],
+    bodyParams: [
+      "embed",
+      "type",
+      "archived",
+      "in_trash",
+      "bookmark",
+      "image",
+      "video",
+      "pdf",
+      "file",
+      "audio",
+      "code",
+      "equation",
+      "divider",
+      "breadcrumb",
+      "table_of_contents",
+      "link_to_page",
+      "table_row",
+      "heading_1",
+      "heading_2",
+      "heading_3",
+      "paragraph",
+      "bulleted_list_item",
+      "numbered_list_item",
+      "quote",
+      "to_do",
+      "toggle",
+      "template",
+      "callout",
+      "synced_block",
+      "table",
+      "column"
+    ],
+    path: (p) => `blocks/${p.block_id}`
+  };
+  exports.deleteBlock = {
+    method: "delete",
+    pathParams: ["block_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `blocks/${p.block_id}`
+  };
+  exports.listBlockChildren = {
+    method: "get",
+    pathParams: ["block_id"],
+    queryParams: ["start_cursor", "page_size"],
+    bodyParams: [],
+    path: (p) => `blocks/${p.block_id}/children`
+  };
+  exports.appendBlockChildren = {
+    method: "patch",
+    pathParams: ["block_id"],
+    queryParams: [],
+    bodyParams: ["children", "after"],
+    path: (p) => `blocks/${p.block_id}/children`
+  };
+  exports.getDataSource = {
+    method: "get",
+    pathParams: ["data_source_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `data_sources/${p.data_source_id}`
+  };
+  exports.updateDataSource = {
+    method: "patch",
+    pathParams: ["data_source_id"],
+    queryParams: [],
+    bodyParams: ["title", "icon", "properties", "in_trash", "archived", "parent"],
+    path: (p) => `data_sources/${p.data_source_id}`
+  };
+  exports.queryDataSource = {
+    method: "post",
+    pathParams: ["data_source_id"],
+    queryParams: ["filter_properties"],
+    bodyParams: [
+      "sorts",
+      "filter",
+      "start_cursor",
+      "page_size",
+      "archived",
+      "in_trash",
+      "result_type"
+    ],
+    path: (p) => `data_sources/${p.data_source_id}/query`
+  };
+  exports.createDataSource = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: ["parent", "properties", "title", "icon"],
+    path: () => `data_sources`
+  };
+  exports.getDatabase = {
+    method: "get",
+    pathParams: ["database_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `databases/${p.database_id}`
+  };
+  exports.updateDatabase = {
+    method: "patch",
+    pathParams: ["database_id"],
+    queryParams: [],
+    bodyParams: [
+      "parent",
+      "title",
+      "description",
+      "is_inline",
+      "icon",
+      "cover",
+      "in_trash",
+      "is_locked"
+    ],
+    path: (p) => `databases/${p.database_id}`
+  };
+  exports.createDatabase = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [
+      "parent",
+      "title",
+      "description",
+      "is_inline",
+      "initial_data_source",
+      "icon",
+      "cover"
+    ],
+    path: () => `databases`
+  };
+  exports.search = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: ["sort", "query", "start_cursor", "page_size", "filter"],
+    path: () => `search`
+  };
+  exports.createComment = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [
+      "rich_text",
+      "attachments",
+      "display_name",
+      "parent",
+      "discussion_id"
+    ],
+    path: () => `comments`
+  };
+  exports.listComments = {
+    method: "get",
+    pathParams: [],
+    queryParams: ["block_id", "start_cursor", "page_size"],
+    bodyParams: [],
+    path: () => `comments`
+  };
+  exports.getComment = {
+    method: "get",
+    pathParams: ["comment_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `comments/${p.comment_id}`
+  };
+  exports.createFileUpload = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [
+      "mode",
+      "filename",
+      "content_type",
+      "number_of_parts",
+      "external_url"
+    ],
+    path: () => `file_uploads`
+  };
+  exports.listFileUploads = {
+    method: "get",
+    pathParams: [],
+    queryParams: ["status", "start_cursor", "page_size"],
+    bodyParams: [],
+    path: () => `file_uploads`
+  };
+  exports.sendFileUpload = {
+    method: "post",
+    pathParams: ["file_upload_id"],
+    queryParams: [],
+    bodyParams: [],
+    formDataParams: ["file", "part_number"],
+    path: (p) => `file_uploads/${p.file_upload_id}/send`
+  };
+  exports.completeFileUpload = {
+    method: "post",
+    pathParams: ["file_upload_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `file_uploads/${p.file_upload_id}/complete`
+  };
+  exports.getFileUpload = {
+    method: "get",
+    pathParams: ["file_upload_id"],
+    queryParams: [],
+    bodyParams: [],
+    path: (p) => `file_uploads/${p.file_upload_id}`
+  };
+  exports.oauthToken = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: [
+      "grant_type",
+      "code",
+      "redirect_uri",
+      "external_account",
+      "refresh_token"
+    ],
+    path: () => `oauth/token`
+  };
+  exports.oauthRevoke = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: ["token"],
+    path: () => `oauth/revoke`
+  };
+  exports.oauthIntrospect = {
+    method: "post",
+    pathParams: [],
+    queryParams: [],
+    bodyParams: ["token"],
+    path: () => `oauth/introspect`
+  };
+  exports.listDataSourceTemplates = {
+    method: "get",
+    pathParams: ["data_source_id"],
+    queryParams: ["name", "start_cursor", "page_size"],
+    bodyParams: [],
+    path: (p) => `data_sources/${p.data_source_id}/templates`
+  };
+});
+
+// node_modules/@notionhq/client/build/package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@notionhq/client",
+    version: "5.3.0",
+    description: "A simple and easy to use client for the Notion API",
+    engines: {
+      node: ">=18"
+    },
+    homepage: "https://developers.notion.com/docs/getting-started",
+    bugs: {
+      url: "https://github.com/makenotion/notion-sdk-js/issues"
+    },
+    repository: {
+      type: "git",
+      url: "https://github.com/makenotion/notion-sdk-js/"
+    },
+    keywords: [
+      "notion",
+      "notionapi",
+      "rest",
+      "notion-api"
+    ],
+    main: "./build/src",
+    types: "./build/src/index.d.ts",
+    scripts: {
+      prepare: "npm run build",
+      prepublishOnly: "npm run checkLoggedIn && npm run lint && npm run test",
+      build: "tsc",
+      prettier: "prettier --write .",
+      lint: "prettier --check . && eslint . --ext .ts && cspell '**/*' ",
+      test: "jest ./test",
+      "check-links": "git ls-files | grep md$ | xargs -n 1 markdown-link-check",
+      prebuild: "npm run clean",
+      clean: "rm -rf ./build",
+      checkLoggedIn: "./scripts/verifyLoggedIn.sh",
+      "install:examples": 'for dir in examples/*/; do echo "Installing dependencies in $dir..."; (cd "$dir" && npm install); done',
+      "examples:install": "npm run install:examples",
+      "examples:typecheck": 'for dir in examples/*/; do echo "Typechecking $dir..."; (cd "$dir" && npx tsc --noEmit) || exit 1; done'
+    },
+    author: "",
+    license: "MIT",
+    files: [
+      "build/package.json",
+      "build/src/**"
+    ],
+    devDependencies: {
+      "@types/jest": "28.1.4",
+      "@typescript-eslint/eslint-plugin": "5.39.0",
+      "@typescript-eslint/parser": "5.39.0",
+      cspell: "5.4.1",
+      eslint: "7.24.0",
+      jest: "28.1.2",
+      "markdown-link-check": "3.13.7",
+      prettier: "2.8.8",
+      "ts-jest": "28.0.5",
+      typescript: "5.9.2"
+    }
+  };
+});
+
+// node_modules/@notionhq/client/build/src/Client.js
+var require_Client = __commonJS((exports) => {
+  var __classPrivateFieldSet = exports && exports.__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+    if (kind === "m")
+      throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f)
+      throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+  };
+  var __classPrivateFieldGet = exports && exports.__classPrivateFieldGet || function(receiver, state, kind, f) {
+    if (kind === "a" && !f)
+      throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+      throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+  };
+  var _Client_auth;
+  var _Client_logLevel;
+  var _Client_logger;
+  var _Client_prefixUrl;
+  var _Client_timeoutMs;
+  var _Client_notionVersion;
+  var _Client_fetch;
+  var _Client_agent;
+  var _Client_userAgent;
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var logging_1 = require_logging();
+  var errors_1 = require_errors();
+  var utils_1 = require_utils();
+  var api_endpoints_1 = require_api_endpoints();
+  var package_json_1 = require_package();
+
+  class Client {
+    constructor(options) {
+      var _a, _b, _c, _d, _e, _f;
+      _Client_auth.set(this, undefined);
+      _Client_logLevel.set(this, undefined);
+      _Client_logger.set(this, undefined);
+      _Client_prefixUrl.set(this, undefined);
+      _Client_timeoutMs.set(this, undefined);
+      _Client_notionVersion.set(this, undefined);
+      _Client_fetch.set(this, undefined);
+      _Client_agent.set(this, undefined);
+      _Client_userAgent.set(this, undefined);
+      this.blocks = {
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getBlock.path(args),
+            method: api_endpoints_1.getBlock.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getBlock.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getBlock.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        update: (args) => {
+          return this.request({
+            path: api_endpoints_1.updateBlock.path(args),
+            method: api_endpoints_1.updateBlock.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.updateBlock.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.updateBlock.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        delete: (args) => {
+          return this.request({
+            path: api_endpoints_1.deleteBlock.path(args),
+            method: api_endpoints_1.deleteBlock.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.deleteBlock.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.deleteBlock.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        children: {
+          append: (args) => {
+            return this.request({
+              path: api_endpoints_1.appendBlockChildren.path(args),
+              method: api_endpoints_1.appendBlockChildren.method,
+              query: (0, utils_1.pick)(args, api_endpoints_1.appendBlockChildren.queryParams),
+              body: (0, utils_1.pick)(args, api_endpoints_1.appendBlockChildren.bodyParams),
+              auth: args === null || args === undefined ? undefined : args.auth
+            });
+          },
+          list: (args) => {
+            return this.request({
+              path: api_endpoints_1.listBlockChildren.path(args),
+              method: api_endpoints_1.listBlockChildren.method,
+              query: (0, utils_1.pick)(args, api_endpoints_1.listBlockChildren.queryParams),
+              body: (0, utils_1.pick)(args, api_endpoints_1.listBlockChildren.bodyParams),
+              auth: args === null || args === undefined ? undefined : args.auth
+            });
+          }
+        }
+      };
+      this.databases = {
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getDatabase.path(args),
+            method: api_endpoints_1.getDatabase.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getDatabase.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getDatabase.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        create: (args) => {
+          return this.request({
+            path: api_endpoints_1.createDatabase.path(),
+            method: api_endpoints_1.createDatabase.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.createDatabase.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.createDatabase.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        update: (args) => {
+          return this.request({
+            path: api_endpoints_1.updateDatabase.path(args),
+            method: api_endpoints_1.updateDatabase.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.updateDatabase.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.updateDatabase.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        }
+      };
+      this.dataSources = {
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getDataSource.path(args),
+            method: api_endpoints_1.getDataSource.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getDataSource.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getDataSource.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        query: (args) => {
+          return this.request({
+            path: api_endpoints_1.queryDataSource.path(args),
+            method: api_endpoints_1.queryDataSource.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.queryDataSource.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.queryDataSource.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        create: (args) => {
+          return this.request({
+            path: api_endpoints_1.createDataSource.path(),
+            method: api_endpoints_1.createDataSource.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.createDataSource.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.createDataSource.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        update: (args) => {
+          return this.request({
+            path: api_endpoints_1.updateDataSource.path(args),
+            method: api_endpoints_1.updateDataSource.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.updateDataSource.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.updateDataSource.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        listTemplates: (args) => {
+          return this.request({
+            path: api_endpoints_1.listDataSourceTemplates.path(args),
+            method: api_endpoints_1.listDataSourceTemplates.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.listDataSourceTemplates.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.listDataSourceTemplates.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        }
+      };
+      this.pages = {
+        create: (args) => {
+          return this.request({
+            path: api_endpoints_1.createPage.path(),
+            method: api_endpoints_1.createPage.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.createPage.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.createPage.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getPage.path(args),
+            method: api_endpoints_1.getPage.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getPage.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getPage.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        update: (args) => {
+          return this.request({
+            path: api_endpoints_1.updatePage.path(args),
+            method: api_endpoints_1.updatePage.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.updatePage.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.updatePage.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        properties: {
+          retrieve: (args) => {
+            return this.request({
+              path: api_endpoints_1.getPageProperty.path(args),
+              method: api_endpoints_1.getPageProperty.method,
+              query: (0, utils_1.pick)(args, api_endpoints_1.getPageProperty.queryParams),
+              body: (0, utils_1.pick)(args, api_endpoints_1.getPageProperty.bodyParams),
+              auth: args === null || args === undefined ? undefined : args.auth
+            });
+          }
+        }
+      };
+      this.users = {
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getUser.path(args),
+            method: api_endpoints_1.getUser.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getUser.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getUser.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        list: (args) => {
+          return this.request({
+            path: api_endpoints_1.listUsers.path(),
+            method: api_endpoints_1.listUsers.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.listUsers.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.listUsers.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        me: (args) => {
+          return this.request({
+            path: api_endpoints_1.getSelf.path(),
+            method: api_endpoints_1.getSelf.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getSelf.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getSelf.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        }
+      };
+      this.comments = {
+        create: (args) => {
+          return this.request({
+            path: api_endpoints_1.createComment.path(),
+            method: api_endpoints_1.createComment.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.createComment.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.createComment.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        list: (args) => {
+          return this.request({
+            path: api_endpoints_1.listComments.path(),
+            method: api_endpoints_1.listComments.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.listComments.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.listComments.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getComment.path(args),
+            method: api_endpoints_1.getComment.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getComment.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.getComment.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        }
+      };
+      this.fileUploads = {
+        create: (args) => {
+          return this.request({
+            path: api_endpoints_1.createFileUpload.path(),
+            method: api_endpoints_1.createFileUpload.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.createFileUpload.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.createFileUpload.bodyParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        retrieve: (args) => {
+          return this.request({
+            path: api_endpoints_1.getFileUpload.path(args),
+            method: api_endpoints_1.getFileUpload.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.getFileUpload.queryParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        list: (args) => {
+          return this.request({
+            path: api_endpoints_1.listFileUploads.path(),
+            method: api_endpoints_1.listFileUploads.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.listFileUploads.queryParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        send: (args) => {
+          return this.request({
+            path: api_endpoints_1.sendFileUpload.path(args),
+            method: api_endpoints_1.sendFileUpload.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.sendFileUpload.queryParams),
+            formDataParams: (0, utils_1.pick)(args, api_endpoints_1.sendFileUpload.formDataParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        },
+        complete: (args) => {
+          return this.request({
+            path: api_endpoints_1.completeFileUpload.path(args),
+            method: api_endpoints_1.completeFileUpload.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.completeFileUpload.queryParams),
+            auth: args === null || args === undefined ? undefined : args.auth
+          });
+        }
+      };
+      this.search = (args) => {
+        return this.request({
+          path: api_endpoints_1.search.path(),
+          method: api_endpoints_1.search.method,
+          query: (0, utils_1.pick)(args, api_endpoints_1.search.queryParams),
+          body: (0, utils_1.pick)(args, api_endpoints_1.search.bodyParams),
+          auth: args === null || args === undefined ? undefined : args.auth
+        });
+      };
+      this.oauth = {
+        token: (args) => {
+          return this.request({
+            path: api_endpoints_1.oauthToken.path(),
+            method: api_endpoints_1.oauthToken.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.oauthToken.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.oauthToken.bodyParams),
+            auth: {
+              client_id: args.client_id,
+              client_secret: args.client_secret
+            }
+          });
+        },
+        introspect: (args) => {
+          return this.request({
+            path: api_endpoints_1.oauthIntrospect.path(),
+            method: api_endpoints_1.oauthIntrospect.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.oauthIntrospect.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.oauthIntrospect.bodyParams),
+            auth: {
+              client_id: args.client_id,
+              client_secret: args.client_secret
+            }
+          });
+        },
+        revoke: (args) => {
+          return this.request({
+            path: api_endpoints_1.oauthRevoke.path(),
+            method: api_endpoints_1.oauthRevoke.method,
+            query: (0, utils_1.pick)(args, api_endpoints_1.oauthRevoke.queryParams),
+            body: (0, utils_1.pick)(args, api_endpoints_1.oauthRevoke.bodyParams),
+            auth: {
+              client_id: args.client_id,
+              client_secret: args.client_secret
+            }
+          });
+        }
+      };
+      __classPrivateFieldSet(this, _Client_auth, options === null || options === undefined ? undefined : options.auth, "f");
+      __classPrivateFieldSet(this, _Client_logLevel, (_a = options === null || options === undefined ? undefined : options.logLevel) !== null && _a !== undefined ? _a : logging_1.LogLevel.WARN, "f");
+      __classPrivateFieldSet(this, _Client_logger, (_b = options === null || options === undefined ? undefined : options.logger) !== null && _b !== undefined ? _b : (0, logging_1.makeConsoleLogger)(package_json_1.name), "f");
+      __classPrivateFieldSet(this, _Client_prefixUrl, `${(_c = options === null || options === undefined ? undefined : options.baseUrl) !== null && _c !== undefined ? _c : "https://api.notion.com"}/v1/`, "f");
+      __classPrivateFieldSet(this, _Client_timeoutMs, (_d = options === null || options === undefined ? undefined : options.timeoutMs) !== null && _d !== undefined ? _d : 60000, "f");
+      __classPrivateFieldSet(this, _Client_notionVersion, (_e = options === null || options === undefined ? undefined : options.notionVersion) !== null && _e !== undefined ? _e : Client.defaultNotionVersion, "f");
+      __classPrivateFieldSet(this, _Client_fetch, (_f = options === null || options === undefined ? undefined : options.fetch) !== null && _f !== undefined ? _f : fetch, "f");
+      __classPrivateFieldSet(this, _Client_agent, options === null || options === undefined ? undefined : options.agent, "f");
+      __classPrivateFieldSet(this, _Client_userAgent, `notionhq-client/${package_json_1.version}`, "f");
+    }
+    async request(args) {
+      const { path, method, query, body, formDataParams, auth } = args;
+      this.log(logging_1.LogLevel.INFO, "request start", { method, path });
+      const bodyAsJsonString = !body || Object.entries(body).length === 0 ? undefined : JSON.stringify(body);
+      const url = new URL(`${__classPrivateFieldGet(this, _Client_prefixUrl, "f")}${path}`);
+      if (query) {
+        for (const [key, value] of Object.entries(query)) {
+          if (value !== undefined) {
+            if (Array.isArray(value)) {
+              for (const val of value) {
+                url.searchParams.append(key, decodeURIComponent(val));
+              }
+            } else {
+              url.searchParams.append(key, String(value));
+            }
+          }
+        }
+      }
+      let authorizationHeader;
+      if (typeof auth === "object") {
+        const unencodedCredential = `${auth.client_id}:${auth.client_secret}`;
+        const encodedCredential = Buffer.from(unencodedCredential).toString("base64");
+        authorizationHeader = { authorization: `Basic ${encodedCredential}` };
+      } else {
+        authorizationHeader = this.authAsHeaders(auth);
+      }
+      const headers = {
+        ...args.headers,
+        ...authorizationHeader,
+        "Notion-Version": __classPrivateFieldGet(this, _Client_notionVersion, "f"),
+        "user-agent": __classPrivateFieldGet(this, _Client_userAgent, "f")
+      };
+      if (bodyAsJsonString !== undefined) {
+        headers["content-type"] = "application/json";
+      }
+      let formData;
+      if (formDataParams) {
+        delete headers["content-type"];
+        formData = new FormData;
+        for (const [key, value] of Object.entries(formDataParams)) {
+          if (typeof value === "string") {
+            formData.append(key, value);
+          } else if (typeof value === "object") {
+            formData.append(key, typeof value.data === "object" ? value.data : new Blob([value.data]), value.filename);
+          }
+        }
+      }
+      try {
+        const response = await errors_1.RequestTimeoutError.rejectAfterTimeout(__classPrivateFieldGet(this, _Client_fetch, "f").call(this, url.toString(), {
+          method: method.toUpperCase(),
+          headers,
+          body: bodyAsJsonString !== null && bodyAsJsonString !== undefined ? bodyAsJsonString : formData,
+          agent: __classPrivateFieldGet(this, _Client_agent, "f")
+        }), __classPrivateFieldGet(this, _Client_timeoutMs, "f"));
+        const responseText = await response.text();
+        if (!response.ok) {
+          throw (0, errors_1.buildRequestError)(response, responseText);
+        }
+        const responseJson = JSON.parse(responseText);
+        this.log(logging_1.LogLevel.INFO, "request success", {
+          method,
+          path,
+          ..."request_id" in responseJson && responseJson.request_id ? { requestId: responseJson.request_id } : {}
+        });
+        return responseJson;
+      } catch (error) {
+        if (!(0, errors_1.isNotionClientError)(error)) {
+          throw error;
+        }
+        this.log(logging_1.LogLevel.WARN, "request fail", {
+          code: error.code,
+          message: error.message,
+          ..."request_id" in error && error.request_id ? { requestId: error.request_id } : {}
+        });
+        if ((0, errors_1.isHTTPResponseError)(error)) {
+          this.log(logging_1.LogLevel.DEBUG, "failed response body", {
+            body: error.body
+          });
+        }
+        throw error;
+      }
+    }
+    log(level, message, extraInfo) {
+      if ((0, logging_1.logLevelSeverity)(level) >= (0, logging_1.logLevelSeverity)(__classPrivateFieldGet(this, _Client_logLevel, "f"))) {
+        __classPrivateFieldGet(this, _Client_logger, "f").call(this, level, message, extraInfo);
+      }
+    }
+    authAsHeaders(auth) {
+      const headers = {};
+      const authHeaderValue = auth !== null && auth !== undefined ? auth : __classPrivateFieldGet(this, _Client_auth, "f");
+      if (authHeaderValue !== undefined) {
+        headers["authorization"] = `Bearer ${authHeaderValue}`;
+      }
+      return headers;
+    }
+  }
+  _Client_auth = new WeakMap, _Client_logLevel = new WeakMap, _Client_logger = new WeakMap, _Client_prefixUrl = new WeakMap, _Client_timeoutMs = new WeakMap, _Client_notionVersion = new WeakMap, _Client_fetch = new WeakMap, _Client_agent = new WeakMap, _Client_userAgent = new WeakMap;
+  Client.defaultNotionVersion = "2025-09-03";
+  exports.default = Client;
+});
+
+// node_modules/@notionhq/client/build/src/helpers.js
+var require_helpers = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.iteratePaginatedAPI = iteratePaginatedAPI;
+  exports.collectPaginatedAPI = collectPaginatedAPI;
+  exports.iterateDataSourceTemplates = iterateDataSourceTemplates;
+  exports.collectDataSourceTemplates = collectDataSourceTemplates;
+  exports.isFullBlock = isFullBlock;
+  exports.isFullPage = isFullPage;
+  exports.isFullDataSource = isFullDataSource;
+  exports.isFullDatabase = isFullDatabase;
+  exports.isFullPageOrDataSource = isFullPageOrDataSource;
+  exports.isFullUser = isFullUser;
+  exports.isFullComment = isFullComment;
+  exports.isTextRichTextItemResponse = isTextRichTextItemResponse;
+  exports.isEquationRichTextItemResponse = isEquationRichTextItemResponse;
+  exports.isMentionRichTextItemResponse = isMentionRichTextItemResponse;
+  exports.extractNotionId = extractNotionId;
+  exports.extractDatabaseId = extractDatabaseId;
+  exports.extractPageId = extractPageId;
+  exports.extractBlockId = extractBlockId;
+  async function* iteratePaginatedAPI(listFn, firstPageArgs) {
+    let nextCursor = firstPageArgs.start_cursor;
+    do {
+      const response = await listFn({
+        ...firstPageArgs,
+        start_cursor: nextCursor
+      });
+      yield* response.results;
+      nextCursor = response.next_cursor;
+    } while (nextCursor);
+  }
+  async function collectPaginatedAPI(listFn, firstPageArgs) {
+    const results = [];
+    for await (const item of iteratePaginatedAPI(listFn, firstPageArgs)) {
+      results.push(item);
+    }
+    return results;
+  }
+  async function* iterateDataSourceTemplates(client, args) {
+    let nextCursor = args.start_cursor;
+    do {
+      const response = await client.dataSources.listTemplates({
+        ...args,
+        start_cursor: nextCursor
+      });
+      yield* response.templates;
+      nextCursor = response.next_cursor;
+    } while (nextCursor);
+  }
+  async function collectDataSourceTemplates(client, args) {
+    const results = [];
+    for await (const template of iterateDataSourceTemplates(client, args)) {
+      results.push(template);
+    }
+    return results;
+  }
+  function isFullBlock(response) {
+    return response.object === "block" && "type" in response;
+  }
+  function isFullPage(response) {
+    return response.object === "page" && "url" in response;
+  }
+  function isFullDataSource(response) {
+    return response.object === "data_source";
+  }
+  function isFullDatabase(response) {
+    return response.object === "database";
+  }
+  function isFullPageOrDataSource(response) {
+    if (response.object === "data_source") {
+      return isFullDataSource(response);
+    } else {
+      return isFullPage(response);
+    }
+  }
+  function isFullUser(response) {
+    return "type" in response;
+  }
+  function isFullComment(response) {
+    return "created_by" in response;
+  }
+  function isTextRichTextItemResponse(richText) {
+    return richText.type === "text";
+  }
+  function isEquationRichTextItemResponse(richText) {
+    return richText.type === "equation";
+  }
+  function isMentionRichTextItemResponse(richText) {
+    return richText.type === "mention";
+  }
+  function extractNotionId(urlOrId) {
+    if (!urlOrId || typeof urlOrId !== "string") {
+      return null;
+    }
+    const trimmed = urlOrId.trim();
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(trimmed)) {
+      return trimmed.toLowerCase();
+    }
+    const compactUuidRegex = /^[0-9a-f]{32}$/i;
+    if (compactUuidRegex.test(trimmed)) {
+      return formatUuid(trimmed);
+    }
+    const pathMatch = trimmed.match(/\/[^/?#]*-([0-9a-f]{32})(?:[/?#]|$)/i);
+    if (pathMatch && pathMatch[1]) {
+      return formatUuid(pathMatch[1]);
+    }
+    const queryMatch = trimmed.match(/[?&](?:p|page_id|database_id)=([0-9a-f]{32})/i);
+    if (queryMatch && queryMatch[1]) {
+      return formatUuid(queryMatch[1]);
+    }
+    const anyMatch = trimmed.match(/([0-9a-f]{32})/i);
+    if (anyMatch && anyMatch[1]) {
+      return formatUuid(anyMatch[1]);
+    }
+    return null;
+  }
+  function formatUuid(compactId) {
+    const clean = compactId.toLowerCase();
+    return `${clean.slice(0, 8)}-${clean.slice(8, 12)}-${clean.slice(12, 16)}-${clean.slice(16, 20)}-${clean.slice(20, 32)}`;
+  }
+  function extractDatabaseId(databaseUrl) {
+    return extractNotionId(databaseUrl);
+  }
+  function extractPageId(pageUrl) {
+    return extractNotionId(pageUrl);
+  }
+  function extractBlockId(urlWithBlock) {
+    if (!urlWithBlock || typeof urlWithBlock !== "string") {
+      return null;
+    }
+    const blockMatch = urlWithBlock.match(/#(?:block-)?([0-9a-f]{32})/i);
+    if (blockMatch && blockMatch[1]) {
+      return formatUuid(blockMatch[1]);
+    }
+    return null;
+  }
+});
+
+// node_modules/@notionhq/client/build/src/index.js
+var require_src = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.extractBlockId = exports.extractPageId = exports.extractDatabaseId = exports.extractNotionId = exports.isFullPageOrDataSource = exports.isFullComment = exports.isFullUser = exports.isFullPage = exports.isFullDatabase = exports.isFullDataSource = exports.isFullBlock = exports.iterateDataSourceTemplates = exports.collectDataSourceTemplates = exports.iteratePaginatedAPI = exports.collectPaginatedAPI = exports.isNotionClientError = exports.RequestTimeoutError = exports.UnknownHTTPResponseError = exports.APIResponseError = exports.ClientErrorCode = exports.APIErrorCode = exports.LogLevel = exports.Client = undefined;
+  var Client_1 = require_Client();
+  Object.defineProperty(exports, "Client", { enumerable: true, get: function() {
+    return Client_1.default;
+  } });
+  var logging_1 = require_logging();
+  Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function() {
+    return logging_1.LogLevel;
+  } });
+  var errors_1 = require_errors();
+  Object.defineProperty(exports, "APIErrorCode", { enumerable: true, get: function() {
+    return errors_1.APIErrorCode;
+  } });
+  Object.defineProperty(exports, "ClientErrorCode", { enumerable: true, get: function() {
+    return errors_1.ClientErrorCode;
+  } });
+  Object.defineProperty(exports, "APIResponseError", { enumerable: true, get: function() {
+    return errors_1.APIResponseError;
+  } });
+  Object.defineProperty(exports, "UnknownHTTPResponseError", { enumerable: true, get: function() {
+    return errors_1.UnknownHTTPResponseError;
+  } });
+  Object.defineProperty(exports, "RequestTimeoutError", { enumerable: true, get: function() {
+    return errors_1.RequestTimeoutError;
+  } });
+  Object.defineProperty(exports, "isNotionClientError", { enumerable: true, get: function() {
+    return errors_1.isNotionClientError;
+  } });
+  var helpers_1 = require_helpers();
+  Object.defineProperty(exports, "collectPaginatedAPI", { enumerable: true, get: function() {
+    return helpers_1.collectPaginatedAPI;
+  } });
+  Object.defineProperty(exports, "iteratePaginatedAPI", { enumerable: true, get: function() {
+    return helpers_1.iteratePaginatedAPI;
+  } });
+  Object.defineProperty(exports, "collectDataSourceTemplates", { enumerable: true, get: function() {
+    return helpers_1.collectDataSourceTemplates;
+  } });
+  Object.defineProperty(exports, "iterateDataSourceTemplates", { enumerable: true, get: function() {
+    return helpers_1.iterateDataSourceTemplates;
+  } });
+  Object.defineProperty(exports, "isFullBlock", { enumerable: true, get: function() {
+    return helpers_1.isFullBlock;
+  } });
+  Object.defineProperty(exports, "isFullDataSource", { enumerable: true, get: function() {
+    return helpers_1.isFullDataSource;
+  } });
+  Object.defineProperty(exports, "isFullDatabase", { enumerable: true, get: function() {
+    return helpers_1.isFullDatabase;
+  } });
+  Object.defineProperty(exports, "isFullPage", { enumerable: true, get: function() {
+    return helpers_1.isFullPage;
+  } });
+  Object.defineProperty(exports, "isFullUser", { enumerable: true, get: function() {
+    return helpers_1.isFullUser;
+  } });
+  Object.defineProperty(exports, "isFullComment", { enumerable: true, get: function() {
+    return helpers_1.isFullComment;
+  } });
+  Object.defineProperty(exports, "isFullPageOrDataSource", { enumerable: true, get: function() {
+    return helpers_1.isFullPageOrDataSource;
+  } });
+  Object.defineProperty(exports, "extractNotionId", { enumerable: true, get: function() {
+    return helpers_1.extractNotionId;
+  } });
+  Object.defineProperty(exports, "extractDatabaseId", { enumerable: true, get: function() {
+    return helpers_1.extractDatabaseId;
+  } });
+  Object.defineProperty(exports, "extractPageId", { enumerable: true, get: function() {
+    return helpers_1.extractPageId;
+  } });
+  Object.defineProperty(exports, "extractBlockId", { enumerable: true, get: function() {
+    return helpers_1.extractBlockId;
+  } });
+});
+
+// src/db-client/DatabaseClient.ts
+var import_client = __toESM(require_src(), 1);
+
+// src/ast/constants.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var PACKAGE_ROOT = path.resolve(__dirname2, "../../");
+var IS_DEV = process.cwd() === PACKAGE_ROOT;
+var DATABASES_DIR = path.join(process.cwd(), "generated");
+var AST_RUNTIME_CONSTANTS = {
+  NOTION_API_VERSION: "2025-09-03",
+  PACKAGE_LOG_PREFIX: "[@elumixor/notion-orm]",
+  CLI_GENERATE_COMMAND: "notion generate",
+  SCHEMA_DRIFT_PREFIX: "Schema drift detected",
+  SCHEMA_DRIFT_HELP_MESSAGE: "Run `notion generate` to refresh all database schemas."
+};
+
+// src/db-client/add.ts
+function buildPropertyValueForAddPage(args) {
+  const { type, value } = args;
+  if (type === "select" && typeof value === "string") {
+    return selectCall({ value });
+  } else if (type === "multi_select" && Array.isArray(value)) {
+    return multiSelectCall({ value });
+  } else if (type === "status" && typeof value === "string") {
+    return statusCall({ option: value });
+  } else if (type === "number" && typeof value === "number") {
+    return numberCall({ value });
+  } else if (type === "email" && typeof value === "string") {
+    return emailCall({ value });
+  } else if (type === "date" && typeof value === "object") {
+    return dateCall({ value });
+  } else if (type === "phone_number" && typeof value === "string") {
+    return phoneNumberCall({ value });
+  } else if (type === "url" && typeof value === "string") {
+    return urlCall({ url: value });
+  } else if (type === "checkbox" && typeof value === "boolean") {
+    return checkboxCall({ checked: value });
+  } else if (type === "title" && typeof value === "string") {
+    return titleCall({ title: value });
+  } else if (type === "rich_text" && typeof value === "string") {
+    return textCall({ text: value });
+  } else {
+    console.error(`'${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${type}' column type currently not supported`);
+  }
+}
+var selectCall = (args) => {
+  const { value } = args;
+  const select = {
+    name: value
+  };
+  return { select };
+};
+var dateCall = (args) => {
+  const { value } = args;
+  return { date: value };
+};
+var phoneNumberCall = (args) => {
+  const { value } = args;
+  return { phone_number: value };
+};
+var statusCall = (args) => {
+  const { option } = args;
+  const status = {
+    name: option
+  };
+  return { status };
+};
+var multiSelectCall = (args) => {
+  const { value } = args;
+  const multi_select = value.map((option) => ({ name: option }));
+  return { multi_select };
+};
+var textCall = (args) => {
+  const { text } = args;
+  const rich_text = [
+    {
+      text: {
+        content: text
+      }
+    }
+  ];
+  return { rich_text };
+};
+var titleCall = (args) => {
+  const { title } = args;
+  const titleObject = [
+    {
+      text: {
+        content: title
+      }
+    }
+  ];
+  return { title: titleObject };
+};
+var numberCall = (args) => {
+  const { value: number } = args;
+  return { number };
+};
+var urlCall = (args) => {
+  const { url } = args;
+  return { url };
+};
+var checkboxCall = (args) => {
+  const { checked: checkbox } = args;
+  return { checkbox };
+};
+var emailCall = (args) => {
+  const { value } = args;
+  return { email: value };
+};
+
+// src/helpers.ts
+function camelize(str) {
+  const cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
+  return cleaned.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
+    if (+match === 0)
+      return "";
+    return index === 0 ? match.toLowerCase() : match.toUpperCase();
+  });
+}
+
+// src/db-client/query.ts
+function buildQueryResponse(res, camelPropertyNameToNameAndTypeMap, validateSchema) {
+  const results = res.results.map((result, index) => {
+    if (result.object === "page" && !("properties" in result)) {
+      console.log("Skipping this page: ", { result });
+      return;
+    }
+    const simpleResult = { id: result.id };
+    const properties = Object.entries(result.properties);
+    for (const [columnName, result2] of properties) {
+      const camelizeColumnName = camelize(columnName);
+      const columnType = camelPropertyNameToNameAndTypeMap[camelizeColumnName]?.type;
+      if (columnType) {
+        simpleResult[camelizeColumnName] = getResponseValue(columnType, result2);
+      }
+    }
+    if (index === 0) {
+      validateSchema(simpleResult);
+    }
+    return simpleResult;
+  }).filter((result) => result !== undefined);
+  return results;
+}
+function getResponseValue(prop, x) {
+  switch (prop) {
+    case "select": {
+      const { select } = x;
+      if (select) {
+        return select["name"];
+      }
+      return null;
+    }
+    case "title": {
+      const { title } = x;
+      if (title) {
+        const combinedText = title.map(({ plain_text }) => plain_text);
+        return combinedText.join("");
+      }
+      return null;
+    }
+    case "url": {
+      const { url } = x;
+      return url;
+    }
+    case "multi_select": {
+      const { multi_select } = x;
+      if (multi_select) {
+        const multi_selectArr = multi_select.map(({ name }) => name);
+        return multi_selectArr;
+      }
+      return null;
+    }
+    case "checkbox": {
+      const { checkbox } = x;
+      return Boolean(checkbox);
+    }
+    case "status": {
+      const { status } = x;
+      if (status) {
+        return status["name"];
+      }
+      return null;
+    }
+    case "rich_text": {
+      const { rich_text } = x;
+      if (rich_text && Array.isArray(rich_text)) {
+        const combinedText = rich_text.map(({ plain_text }) => plain_text);
+        return combinedText.join("");
+      }
+      return null;
+    }
+    case "number": {
+      const { number } = x;
+      return number;
+    }
+    case "formula": {
+      const { formula } = x;
+      if (!formula)
+        return null;
+      if (formula.type === "date")
+        return formula.date;
+      return formula[formula.type] ?? null;
+    }
+    case "rollup": {
+      const { rollup } = x;
+      if (!rollup)
+        return null;
+      switch (rollup.type) {
+        case "number":
+          return rollup.number;
+        case "date":
+          return rollup.date;
+        case "array":
+          return rollup.array;
+        default:
+          return null;
+      }
+    }
+    case "relation": {
+      const { relation } = x;
+      if (!Array.isArray(relation))
+        return null;
+      return relation.map(({ id }) => id);
+    }
+    default: {
+      return null;
+    }
+  }
+}
+function recursivelyBuildFilter(queryFilter, camelPropertyNameToNameAndTypeMap) {
+  for (const prop in queryFilter) {
+    if (prop === "and" || prop === "or") {
+      const compoundFilters = queryFilter[prop];
+      const compoundApiFilters = compoundFilters.map((i) => {
+        return recursivelyBuildFilter(i, camelPropertyNameToNameAndTypeMap);
+      });
+      const temp = {
+        ...prop === "and" ? { and: compoundApiFilters } : { or: compoundApiFilters }
+      };
+      return temp;
+    } else {
+      const propType = camelPropertyNameToNameAndTypeMap[prop].type;
+      const temp = {
+        property: camelPropertyNameToNameAndTypeMap[prop].columnName
+      };
+      temp[propType] = queryFilter[prop];
+      return temp;
+    }
+  }
+}
+
+// src/db-client/DatabaseClient.ts
+class DatabaseClient {
+  client;
+  id;
+  camelPropertyNameToNameAndTypeMap;
+  schema;
+  name;
+  loggedSchemaValidationIssues;
+  constructor(args) {
+    const fetchImpl = typeof fetch !== "undefined" ? fetch.bind(globalThis) : undefined;
+    this.client = new import_client.Client({
+      auth: args.auth,
+      notionVersion: AST_RUNTIME_CONSTANTS.NOTION_API_VERSION,
+      fetch: fetchImpl
+    });
+    this.id = args.id;
+    this.camelPropertyNameToNameAndTypeMap = args.camelPropertyNameToNameAndTypeMap;
+    this.schema = args.schema;
+    this.name = args.name;
+    this.loggedSchemaValidationIssues = new Set;
+  }
+  async add(args) {
+    const { properties: pageObject, icon } = args;
+    const callBody = {
+      parent: {
+        data_source_id: this.id,
+        type: "data_source_id"
+      },
+      properties: {}
+    };
+    callBody.icon = icon;
+    Object.entries(pageObject).forEach(([propertyName, value]) => {
+      const { type, columnName } = this.camelPropertyNameToNameAndTypeMap[propertyName];
+      const columnObject = buildPropertyValueForAddPage({
+        type,
+        value
+      });
+      if (callBody.properties && columnObject) {
+        callBody.properties[columnName] = columnObject;
+      }
+    });
+    return await this.client.pages.create(callBody);
+  }
+  async update(id, properties, icon) {
+    const callBody = { page_id: id, properties: {} };
+    if (icon !== undefined)
+      callBody.icon = icon;
+    Object.entries(properties).forEach(([propertyName, value]) => {
+      const { type, columnName } = this.camelPropertyNameToNameAndTypeMap[propertyName];
+      const columnObject = buildPropertyValueForAddPage({ type, value });
+      if (callBody.properties && columnObject) {
+        callBody.properties[columnName] = columnObject;
+      }
+    });
+    await this.client.pages.update(callBody);
+  }
+  async delete(id) {
+    await this.client.pages.update({ page_id: id, archived: true });
+  }
+  async upsert(args) {
+    const queryCall = this.buildQueryCall({ filter: args.where });
+    const response = await this.client.dataSources.query({ ...queryCall, page_size: 1 });
+    if (response.results.length > 0) {
+      const existingId = response.results[0].id;
+      await this.update(existingId, args.properties, args.icon);
+      return { created: false, id: existingId };
+    }
+    const created = await this.add({ properties: args.properties, icon: args.icon });
+    return { created: true, id: created.id };
+  }
+  query(query) {
+    const queryCall = this.buildQueryCall(query);
+    if (query.pagination)
+      return this.paginatedIterable(queryCall, query);
+    return this.fetchAllPages(queryCall, query);
+  }
+  buildQueryCall(query) {
+    const queryCall = { data_source_id: this.id };
+    if (query.sort?.length) {
+      queryCall["sorts"] = query.sort.map((s) => {
+        if (!("property" in s))
+          return s;
+        return { ...s, property: this.camelPropertyNameToNameAndTypeMap[s.property]?.columnName ?? s.property };
+      });
+    }
+    if (query.filter) {
+      queryCall["filter"] = recursivelyBuildFilter(query.filter, this.camelPropertyNameToNameAndTypeMap);
+    }
+    return queryCall;
+  }
+  async fetchAllPages(queryCall, query) {
+    const allResults = [];
+    let cursor;
+    let isFirst = true;
+    do {
+      const response = await this.client.dataSources.query({ ...queryCall, start_cursor: cursor, page_size: 100 });
+      const page = buildQueryResponse(response, this.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => this.validateDatabaseSchema(r) : () => {});
+      isFirst = false;
+      allResults.push(...this.applySelectOmit(page, query.select, query.omit));
+      cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
+    } while (cursor && (!query.limit || allResults.length < query.limit));
+    return query.limit ? allResults.slice(0, query.limit) : allResults;
+  }
+  paginatedIterable(queryCall, query) {
+    const self = this;
+    const pageSize = query.pagination.pageSize;
+    return {
+      [Symbol.asyncIterator]: async function* () {
+        let cursor;
+        let isFirst = true;
+        let yielded = 0;
+        do {
+          const response = await self.client.dataSources.query({ ...queryCall, start_cursor: cursor, page_size: pageSize });
+          const page = buildQueryResponse(response, self.camelPropertyNameToNameAndTypeMap, isFirst ? (r) => self.validateDatabaseSchema(r) : () => {});
+          isFirst = false;
+          for (const item of self.applySelectOmit(page, query.select, query.omit)) {
+            yield item;
+            if (query.limit && ++yielded >= query.limit)
+              return;
+          }
+          cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
+        } while (cursor);
+      }
+    };
+  }
+  applySelectOmit(results, select, omit) {
+    if (!select && !omit)
+      return results;
+    return results.map((result) => {
+      const out = { id: result.id };
+      if (select) {
+        for (const key of Object.keys(select))
+          if (key in result)
+            out[key] = result[key];
+      } else if (omit) {
+        for (const key of Object.keys(result))
+          if (key !== "id" && !omit[key])
+            out[key] = result[key];
+      }
+      return out;
+    });
+  }
+  validateDatabaseSchema(result) {
+    if (!this.schema) {
+      return;
+    }
+    const schemaLabel = this.name ?? this.id;
+    const remoteColumnNames = new Set(Object.keys(result));
+    const missingProperties = [];
+    for (const propName in this.camelPropertyNameToNameAndTypeMap) {
+      if (!remoteColumnNames.has(propName)) {
+        missingProperties.push(propName);
+      }
+    }
+    if (missingProperties.length > 0) {
+      const issueSignature2 = JSON.stringify({
+        type: "missing_properties",
+        properties: missingProperties
+      });
+      if (!this.loggedSchemaValidationIssues.has(issueSignature2)) {
+        this.loggedSchemaValidationIssues.add(issueSignature2);
+        console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
+					
+Missing properties: ${missingProperties.map((prop) => `\`${prop}\``).join(", ")}
+					
+
+✅ ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_HELP_MESSAGE}
+					`);
+      }
+    }
+    for (const remoteColName of remoteColumnNames) {
+      if (remoteColName === "id")
+        continue;
+      if (!this.camelPropertyNameToNameAndTypeMap[remoteColName]) {
+        const issueSignature2 = JSON.stringify({
+          type: "unexpected_property",
+          property: remoteColName
+        });
+        if (!this.loggedSchemaValidationIssues.has(issueSignature2)) {
+          this.loggedSchemaValidationIssues.add(issueSignature2);
+          console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
+						
+Unexpected property found in remote data: \`${remoteColName}\`
+						
+
+✅ ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_HELP_MESSAGE}
+						`);
+        }
+      }
+    }
+    const parseResult = this.schema.safeParse(result);
+    if (parseResult.success) {
+      return;
+    }
+    const issueSignature = JSON.stringify(parseResult.error.issues.map((issue) => ({
+      code: issue.code,
+      path: issue.path,
+      message: issue.message
+    })));
+    if (this.loggedSchemaValidationIssues.has(issueSignature)) {
+      return;
+    }
+    this.loggedSchemaValidationIssues.add(issueSignature);
+    console.error(`⚠️ ${AST_RUNTIME_CONSTANTS.PACKAGE_LOG_PREFIX} ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_PREFIX} for the following Notion database ${schemaLabel}
+			
+Validation issues: ${parseResult.error.issues.map((issue) => `\`${issue.path.join(".")}: ${issue.message}\``).join(", ")}
+			
+
+✅ ${AST_RUNTIME_CONSTANTS.SCHEMA_DRIFT_HELP_MESSAGE}
+			`);
+    console.log("Validation details:", {
+      issues: parseResult.error.issues,
+      result
+    });
+  }
+}
+export {
+  DatabaseClient
+};