Created
November 12, 2025 16:47
-
-
Save EndyKaufman/27a166d17786bc93764dc81a163a6159 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| This file is a merged representation of a subset of the codebase, containing files not matching ignore patterns, combined into a single document by Repomix. | |
| The content has been processed where security check has been disabled. | |
| # File Summary | |
| ## Purpose | |
| This file contains a packed representation of a subset of the repository's contents that is considered the most important context. | |
| It is designed to be easily consumable by AI systems for analysis, code review, | |
| or other automated processes. | |
| ## File Format | |
| The content is organized as follows: | |
| 1. This summary section | |
| 2. Repository information | |
| 3. Directory structure | |
| 4. Repository files (if enabled) | |
| 5. Multiple file entries, each consisting of: | |
| a. A header with the file path (## File: path/to/file) | |
| b. The full contents of the file in a code block | |
| ## Usage Guidelines | |
| - This file should be treated as read-only. Any changes should be made to the | |
| original repository files, not this packed version. | |
| - When processing this file, use the file path to distinguish | |
| between different files in the repository. | |
| - Be aware that this file may contain sensitive information. Handle it with | |
| the same level of security as you would the original repository. | |
| ## Notes | |
| - Some files may have been excluded based on .gitignore rules and Repomix's configuration | |
| - Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files | |
| - Files matching these patterns are excluded: **/**/CHANGELOG.md | |
| - Files matching patterns in .gitignore are excluded | |
| - Files matching default ignore patterns are excluded | |
| - Security check has been disabled - content may contain sensitive information | |
| - Files are sorted by Git change count (files with more changes are at the bottom) | |
| # Directory Structure | |
| ``` | |
| .github/ | |
| workflows/ | |
| android-build.yml | |
| release.yml | |
| ionic_capacitor/ | |
| .gitignore | |
| build-android.sh | |
| Dockerfile | |
| package.json | |
| README_RU.md | |
| README.md | |
| mobile/ | |
| .vscode/ | |
| extensions.json | |
| settings.json | |
| android/ | |
| app/ | |
| src/ | |
| androidTest/ | |
| java/ | |
| com/ | |
| getcapacitor/ | |
| myapp/ | |
| ExampleInstrumentedTest.java | |
| main/ | |
| java/ | |
| ru/ | |
| site15/ | |
| MyDashboard/ | |
| MainActivity.java | |
| res/ | |
| drawable/ | |
| ic_launcher_background.xml | |
| drawable-v24/ | |
| ic_launcher_foreground.xml | |
| layout/ | |
| activity_main.xml | |
| mipmap-anydpi-v26/ | |
| ic_launcher_round.xml | |
| ic_launcher.xml | |
| values/ | |
| ic_launcher_background.xml | |
| strings.xml | |
| styles.xml | |
| xml/ | |
| file_paths.xml | |
| AndroidManifest.xml | |
| test/ | |
| java/ | |
| com/ | |
| getcapacitor/ | |
| myapp/ | |
| ExampleUnitTest.java | |
| .gitignore | |
| build.gradle | |
| capacitor.build.gradle | |
| proguard-rules.pro | |
| gradle/ | |
| wrapper/ | |
| gradle-wrapper.properties | |
| .gitignore | |
| build.gradle | |
| capacitor.settings.gradle | |
| gradle.properties | |
| gradlew | |
| gradlew.bat | |
| settings.gradle | |
| variables.gradle | |
| src/ | |
| app/ | |
| explore-container/ | |
| explore-container.component.html | |
| explore-container.component.scss | |
| explore-container.component.spec.ts | |
| explore-container.component.ts | |
| tab1/ | |
| tab1.page.html | |
| tab1.page.spec.ts | |
| tab1.page.ts | |
| tab2/ | |
| tab2.page.html | |
| tab2.page.spec.ts | |
| tab2.page.ts | |
| tab3/ | |
| tab3.page.html | |
| tab3.page.spec.ts | |
| tab3.page.ts | |
| tabs/ | |
| tabs.page.html | |
| tabs.page.scss | |
| tabs.page.spec.ts | |
| tabs.page.ts | |
| tabs.routes.ts | |
| app.component.html | |
| app.component.spec.ts | |
| app.component.ts | |
| app.routes.ts | |
| assets/ | |
| shapes.svg | |
| environments/ | |
| environment.prod.ts | |
| environment.ts | |
| theme/ | |
| variables.scss | |
| global.scss | |
| index.html | |
| main.ts | |
| polyfills.ts | |
| test.ts | |
| zone-flags.ts | |
| .browserslistrc | |
| .editorconfig | |
| .eslintrc.json | |
| .gitignore | |
| angular.json | |
| capacitor.config.ts | |
| ionic.config.json | |
| karma.conf.js | |
| package.json | |
| README_RU.md | |
| README.md | |
| tsconfig.app.json | |
| tsconfig.json | |
| tsconfig.spec.json | |
| update-capacitor-config.js | |
| web/ | |
| .vscode/ | |
| extensions.json | |
| launch.json | |
| tasks.json | |
| prisma/ | |
| migrations/ | |
| 20251030031037_add_users/ | |
| migration.sql | |
| 20251030194718_add_telegram_user_data_to_user/ | |
| migration.sql | |
| 20251031054243_update_pk/ | |
| migration.sql | |
| 20251031054333_add_session/ | |
| migration.sql | |
| 20251031054509_change_pk_name/ | |
| migration.sql | |
| 20251031054615_change_external_user_id_to_telegram_user_id_string/ | |
| migration.sql | |
| 20251031071721_add_uniq_index_to_user/ | |
| migration.sql | |
| 20251110085211_append_all_need_tables_for_dashboards/ | |
| migration.sql | |
| 20251110085731_add_widget_log_table/ | |
| migration.sql | |
| 20251110091115_append_anonymous_id_to_user/ | |
| migration.sql | |
| 20251110092600_append_is_black_theme_to_all_tables/ | |
| migration.sql | |
| migration_lock.toml | |
| schema.prisma | |
| public/ | |
| analog.svg | |
| vite.svg | |
| src/ | |
| app/ | |
| components/ | |
| telegram/ | |
| ngx-telegram-widget.component.ts | |
| theme/ | |
| color-scheme-switcher.component.ts | |
| directives/ | |
| if-logged.directive.ts | |
| generated/ | |
| prisma/ | |
| internal/ | |
| class.ts | |
| prismaNamespace.ts | |
| prismaNamespaceBrowser.ts | |
| models/ | |
| Dashboard.ts | |
| Session.ts | |
| User.ts | |
| Widget.ts | |
| WidgetLog.ts | |
| browser.ts | |
| client.ts | |
| commonInputTypes.ts | |
| enums.ts | |
| models.ts | |
| pages/ | |
| dashboards.[dashboardId].delete.page.ts | |
| dashboards.[dashboardId].link-device.page.ts | |
| dashboards.[dashboardId].page.ts | |
| dashboards.page.ts | |
| login.page.ts | |
| services/ | |
| auth.service.ts | |
| local-storage.service.ts | |
| modal.component.ts | |
| profile.service.ts | |
| session.service.ts | |
| telegram-settings.service.ts | |
| telegram.service.ts | |
| theme.service.ts | |
| utils/ | |
| is-ssr.ts | |
| local-storage.ts | |
| window.ts | |
| app.config.server.ts | |
| app.config.ts | |
| app.spec.ts | |
| app.ts | |
| trpc-client.ts | |
| server/ | |
| generated/ | |
| prisma/ | |
| internal/ | |
| class.ts | |
| prismaNamespace.ts | |
| prismaNamespaceBrowser.ts | |
| models/ | |
| Dashboard.ts | |
| Session.ts | |
| User.ts | |
| Widget.ts | |
| WidgetLog.ts | |
| browser.ts | |
| client.ts | |
| commonInputTypes.ts | |
| enums.ts | |
| models.ts | |
| routes/ | |
| api/ | |
| trpc/ | |
| [trpc].ts | |
| v1/ | |
| hello.ts | |
| trpc/ | |
| routers/ | |
| auth.ts | |
| dashboards.ts | |
| index.ts | |
| telegram.ts | |
| users.ts | |
| widgets.ts | |
| context.ts | |
| trpc.ts | |
| types/ | |
| EnvSchema.ts | |
| LinkDeviceQRSchema.ts | |
| TelegramSettingsSchema.ts | |
| TelegramUserDataSchema.ts | |
| UserSchema.ts | |
| utils/ | |
| check-signature.ts | |
| widgets/ | |
| clock-widget.ts | |
| constants.ts | |
| env.ts | |
| prisma.ts | |
| main.server.ts | |
| main.ts | |
| styles.css | |
| test-setup.ts | |
| vite-env.d.ts | |
| .editorconfig | |
| .gitignore | |
| angular.json | |
| example.env | |
| index.html | |
| package.json | |
| prisma.config.ts | |
| README_RU.md | |
| README.md | |
| tsconfig.app.json | |
| tsconfig.json | |
| tsconfig.spec.json | |
| vite.config.ts | |
| README_RU.md | |
| README.md | |
| ``` | |
| # Files | |
| ## File: .github/workflows/android-build.yml | |
| ````yaml | |
| name: Build Android APK | |
| on: | |
| push: | |
| branches: ["skip-main"] | |
| pull_request: | |
| branches: ["skip-main"] | |
| workflow_dispatch: | |
| jobs: | |
| build-android: | |
| runs-on: ubuntu-latest | |
| steps: | |
| - name: Checkout code | |
| uses: actions/checkout@v4 | |
| - name: Set up Docker Buildx | |
| uses: docker/setup-buildx-action@v3 | |
| - name: Create keystore from secrets | |
| run: | | |
| echo "${{ secrets.KEYSTORE }}" | base64 --decode > ${{ github.workspace }}/mobile/my-dashboard.jks | |
| ls ${{ github.workspace }}/mobile | |
| - name: Run Android build in Docker container | |
| run: | | |
| docker run --rm \ | |
| -e KEYSTORE_PASSWORD="${{ secrets.KEYSTORE_PASSWORD }}" \ | |
| -e KEYSTORE_ALIAS="${{ secrets.KEYSTORE_ALIAS }}" \ | |
| -e KEYSTORE_ALIAS_PASSWORD="${{ secrets.KEYSTORE_ALIAS_PASSWORD }}" \ | |
| -e PRISMA_ENGINES_MIRROR="https://registry.npmmirror.com/-/binary/prisma" \ | |
| -v "${{ github.workspace }}/mobile:/app" \ | |
| endykaufman/ionic-capacitor:latest | |
| - name: List generated APK files | |
| run: | | |
| ls -la ${{ github.workspace }}/mobile/android/app/build/outputs/apk/release/ | |
| - name: Upload APK artifacts | |
| uses: actions/upload-artifact@v4 | |
| with: | |
| name: android-apk-release | |
| path: ${{ github.workspace }}/mobile/android/app/build/outputs/apk/release/*.apk | |
| if-no-files-found: error | |
| ```` | |
| ## File: .github/workflows/release.yml | |
| ````yaml | |
| name: Auto Bump Version, Build & Publish | |
| on: | |
| push: | |
| branches: | |
| - main | |
| jobs: | |
| bump: | |
| runs-on: ubuntu-latest | |
| permissions: | |
| contents: write | |
| packages: write | |
| steps: | |
| - name: Checkout repository | |
| uses: actions/checkout@v4 | |
| with: | |
| fetch-depth: 0 | |
| - name: Setup Node.js | |
| uses: actions/setup-node@v4 | |
| with: | |
| node-version: 23.11.0 | |
| # 🔍 Проверяем наличие [need ci] | |
| - name: Check if [need ci] present | |
| id: need_ci | |
| run: | | |
| if git log ${{ github.event.before }}..${{ github.sha }} --pretty=format:"%s%b" | grep -q "\[need ci\]"; then | |
| echo "force_run=true" >> $GITHUB_OUTPUT | |
| echo "✅ Found [need ci] — forcing full pipeline" | |
| else | |
| echo "force_run=false" >> $GITHUB_OUTPUT | |
| echo "ℹ️ No [need ci] found" | |
| fi | |
| # 🔍 Определяем изменённые проекты | |
| - name: Detect changed projects | |
| id: detect | |
| run: | | |
| PROJECTS=$(find . -maxdepth 1 -type d ! -path . | while read d; do | |
| if [ -f "$d/package.json" ]; then echo "$(basename "$d")"; fi | |
| done) | |
| if [ "${{ steps.need_ci.outputs.force_run }}" = "true" ]; then | |
| CHANGED_PROJECTS="$PROJECTS" | |
| else | |
| CHANGED=$(git diff --name-only ${{ github.event.before }} ${{ github.sha }} | cut -d/ -f1 | sort | uniq) | |
| CHANGED_PROJECTS=$(echo "$PROJECTS" | grep -Fxf <(echo "$CHANGED") || true) | |
| fi | |
| echo "Changed projects: $CHANGED_PROJECTS" | |
| CHANGED_PROJECTS_CLEAN=$(echo "$CHANGED_PROJECTS" | tr '\n' ' ' | sed 's/ $//') | |
| ENCODED=$(echo -n "$CHANGED_PROJECTS_CLEAN" | base64) | |
| echo "changed_projects_base64=$ENCODED" >> $GITHUB_OUTPUT | |
| # 🧩 Определяем тип bump'а | |
| - name: Determine bump type | |
| id: bump_type | |
| run: | | |
| MESSAGES=$(git log ${{ github.event.before }}..${{ github.sha }} --pretty=format:"%s%n%b") | |
| if echo "$MESSAGES" | grep -qi "BREAKING CHANGE"; then | |
| BUMP=major | |
| elif echo "$MESSAGES" | grep -Eqi "^feat"; then | |
| BUMP=minor | |
| elif echo "$MESSAGES" | grep -Eqi "^fix"; then | |
| BUMP=patch | |
| else | |
| BUMP=none | |
| fi | |
| echo "bump=$BUMP" >> $GITHUB_OUTPUT | |
| echo "Detected bump type: $BUMP" | |
| # 🚀 Bump, Build & Docker | |
| - name: Bump, Build & Docker | |
| if: steps.need_ci.outputs.force_run == 'true' || (steps.bump_type.outputs.bump != 'none' && steps.detect.outputs.changed_projects_base64 != '') | |
| id: bump_versions | |
| env: | |
| DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USERNAME }} | |
| DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }} | |
| run: | | |
| sudo apt-get install -y jq | |
| npm install -g conventional-changelog-cli | |
| if [ -n "${DOCKERHUB_USER}" ] && [ -n "${DOCKERHUB_TOKEN}" ]; then | |
| echo "${DOCKERHUB_TOKEN}" | docker login -u "${DOCKERHUB_USER}" --password-stdin | |
| else | |
| echo "⚠️ DockerHub credentials missing — skipping Docker publish" | |
| fi | |
| BUMP=${{ steps.bump_type.outputs.bump }} | |
| CHANGED_PROJECTS=$(echo "${{ steps.detect.outputs.changed_projects_base64 }}" | base64 --decode) | |
| if [ -z "$CHANGED_PROJECTS" ]; then | |
| echo "ℹ️ No changed projects detected. Exiting." | |
| exit 0 | |
| fi | |
| TAGS="" | |
| for project in $CHANGED_PROJECTS; do | |
| if [ -f "$project/package.json" ]; then | |
| cd $project | |
| NAME=$(jq -r '.name' package.json) | |
| DESC=$(jq -r '.description // "No description"' package.json) | |
| OLD_VERSION=$(jq -r '.version' package.json) | |
| if [ "$BUMP" != "none" ]; then | |
| npm version $BUMP --no-git-tag-version | |
| fi | |
| NEW_VERSION=$(jq -r '.version' package.json) | |
| conventional-changelog -p angular -i CHANGELOG.md -s -r 1 || true | |
| if jq -e '.scripts.build' package.json >/dev/null; then | |
| npm ci | |
| npm run build || echo "⚠️ Build failed for $project" | |
| fi | |
| if [ -f "Dockerfile" ] && [ -n "${DOCKERHUB_USER}" ]; then | |
| IMAGE_NAME="${DOCKERHUB_USER}/${NAME}" | |
| docker build -t "$IMAGE_NAME:$NEW_VERSION" -t "$IMAGE_NAME:latest" \ | |
| --label "org.opencontainers.image.title=$NAME" \ | |
| --label "org.opencontainers.image.description=$DESC" \ | |
| --label "org.opencontainers.image.version=$NEW_VERSION" \ | |
| --label "org.opencontainers.image.source=https://github.com/${{ github.repository }}" \ | |
| . || true | |
| docker push "$IMAGE_NAME:$NEW_VERSION" || true | |
| docker push "$IMAGE_NAME:latest" || true | |
| fi | |
| if [ -f "capacitor.config.ts" ]; then | |
| echo "${{ secrets.KEYSTORE }}" | base64 --decode > "${{ github.workspace }}/$project/my-dashboard.jks" | |
| docker run --rm \ | |
| -e KEYSTORE_PASSWORD="${{ secrets.KEYSTORE_PASSWORD }}" \ | |
| -e KEYSTORE_ALIAS="${{ secrets.KEYSTORE_ALIAS }}" \ | |
| -e KEYSTORE_ALIAS_PASSWORD="${{ secrets.KEYSTORE_ALIAS_PASSWORD }}" \ | |
| -e PRISMA_ENGINES_MIRROR="https://registry.npmmirror.com/-/binary/prisma" \ | |
| -v "${{ github.workspace }}/$project:/app" \ | |
| endykaufman/ionic-capacitor:latest | |
| mkdir -p ${{ github.workspace }}/$project/artifacts | |
| cp -R ${{ github.workspace }}/$project/android/app/build/outputs/apk/release/* ${{ github.workspace }}/$project/artifacts/ | |
| fi | |
| cd - | |
| TAG="${project}@${NEW_VERSION}" | |
| git rev-parse "$TAG" >/dev/null 2>&1 || git tag "$TAG" | |
| TAGS="$TAGS $TAG" | |
| fi | |
| done | |
| echo "tags=$TAGS" >> $GITHUB_OUTPUT | |
| # 💾 Commit and push changes | |
| - name: Commit and push changes | |
| if: steps.need_ci.outputs.force_run == 'true' || (steps.bump_type.outputs.bump != 'none' && steps.detect.outputs.changed_projects_base64 != '') | |
| run: | | |
| git config user.name "github-actions[bot]" | |
| git config user.email "github-actions[bot]@users.noreply.github.com" | |
| git add */package.json */CHANGELOG.md || true | |
| git commit -m "chore: auto bump version [skip ci]" || echo "No changes" | |
| git push origin main | |
| git push origin --tags | |
| # 📦 Upload artifacts | |
| - name: Upload artifacts | |
| if: steps.need_ci.outputs.force_run == 'true' || steps.bump_versions.outputs.tags != '' | |
| uses: actions/upload-artifact@v4 | |
| with: | |
| name: project-builds | |
| path: "**/artifacts/**" | |
| if-no-files-found: ignore | |
| - name: Create releases & send Telegram message | |
| if: steps.need_ci.outputs.force_run == 'true' || steps.bump_versions.outputs.tags != '' | |
| env: | |
| GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} | |
| DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USERNAME }} | |
| TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }} | |
| run: | | |
| # --- функция для экранирования Markdown-спецсимволов | |
| escape_markdown() { | |
| local text="$1" | |
| text="${text//_/\\_}" | |
| text="${text//\*/\\*}" | |
| text="${text//~/\\~}" | |
| echo "$text" | |
| } | |
| # --- проверка [hidden] | |
| if git log ${{ github.event.before }}..${{ github.sha }} --pretty=format:"%s%b" | grep -q "\[hidden\]"; then | |
| SKIP_TELEGRAM=1 | |
| else | |
| SKIP_TELEGRAM=0 | |
| fi | |
| TAGS="${{ steps.bump_versions.outputs.tags }}" | |
| if [ -z "$TAGS" ] && [ "${{ steps.need_ci.outputs.force_run }}" = "true" ]; then | |
| TAGS=$(find . -maxdepth 1 -type d ! -path . -exec bash -c 'cd {} && if [ -f package.json ]; then NAME=$(jq -r .name package.json); VER=$(jq -r .version package.json); echo "$(basename "$PWD")@$VER"; fi' \;) | |
| fi | |
| for TAG in $TAGS; do | |
| PROJECT=$(echo "$TAG" | cut -d@ -f1) | |
| PKG="$PROJECT/package.json" | |
| [ ! -f "$PKG" ] && continue | |
| NAME=$(jq -r '.name' "$PKG") | |
| VERSION=$(jq -r '.version' "$PKG") | |
| DESC=$(jq -r '.description // "No description"' "$PKG") | |
| CHANGELOG_PATH="$PROJECT/CHANGELOG.md" | |
| ARTIFACTS_PATH="$PROJECT/artifacts" | |
| RELEASE_URL="https://github.com/${{ github.repository }}/releases/tag/${TAG}" | |
| PROJECT_URL="https://github.com/${{ github.repository }}/tree/main/${PROJECT}" | |
| PIPELINE_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}" | |
| # --- GitHub release через файл с переносами | |
| if [ -f "$CHANGELOG_PATH" ]; then | |
| BODY=$(git log --pretty=format:"• %s" ${{ github.event.before }}..${{ github.sha }} -- "$PROJECT") | |
| [ -z "$BODY" ] && BODY=$(git log -n 5 --pretty=format:"• %s") | |
| else | |
| BODY=$(git log --pretty=format:"• %s" ${{ github.event.before }}..${{ github.sha }} -- "$PROJECT") | |
| fi | |
| NOTES="🚀 ${NAME} v${VERSION} released! | |
| Changelog: | |
| ${BODY} | |
| " | |
| echo "$NOTES" > release_notes.txt | |
| echo "ARTIFACTS_PATH: $ARTIFACTS_PATH" | |
| if [ -d "$ARTIFACTS_PATH" ]; then | |
| FILES=$(find "$ARTIFACTS_PATH" -type f) | |
| echo "FILES: $FILES" | |
| gh release create "$TAG" --title "$TAG" --notes-file release_notes.txt $FILES || echo "Release exists" | |
| else | |
| gh release create "$TAG" --title "$TAG" --notes-file release_notes.txt || echo "Release exists" | |
| fi | |
| # --- Telegram | |
| if [ "$SKIP_TELEGRAM" -eq 0 ]; then | |
| TG_BODY=$(echo -e "🚀 ${NAME} v${VERSION} released!%0A%0A_${DESC}_%0A%0A") | |
| if [ -f "$CHANGELOG_PATH" ]; then | |
| BODY=$(git log --pretty=format:"• %s" ${{ github.event.before }}..${{ github.sha }} -- "$PROJECT") | |
| [ -z "$BODY" ] && BODY=$(git log -n 5 --pretty=format:"• %s") | |
| # Заменяем переносы на %0A | |
| NEW_TG_NOTES=$(echo "$BODY" | sed ':a;N;$!ba;s/\n/%0A/g') | |
| # Экранирование спецсимволов | |
| NEW_TG_NOTES=$(escape_markdown "$NEW_TG_NOTES") | |
| TG_BODY+="*Changelog:*%0A${NEW_TG_NOTES}%0A" | |
| else | |
| BODY=$(git log --pretty=format:"• %s" ${{ github.event.before }}..${{ github.sha }} -- "$PROJECT") | |
| # Заменяем переносы на %0A | |
| NEW_TG_NOTES=$(echo "$BODY" | sed ':a;N;$!ba;s/\n/%0A/g') | |
| # Экранирование спецсимволов | |
| NEW_TG_NOTES=$(escape_markdown "$NEW_TG_NOTES") | |
| TG_BODY+="*Recent commits:*%0A${NEW_TG_NOTES}%0A" | |
| fi | |
| BUTTONS="[" | |
| if [ -d "$ARTIFACTS_PATH" ]; then | |
| while IFS= read -r FILE; do | |
| EXT="${FILE##*.}" | |
| if [[ "$EXT" =~ ^(apk|exe|zip|html)$ ]]; then | |
| BASENAME=$(basename "$FILE") | |
| SAFE_TAG=$(echo "$TAG" | sed 's/@/%40/g') # <-- заменяем @ на %40 | |
| FILE_URL="https://github.com/${{ github.repository }}/releases/download/${SAFE_TAG}/${BASENAME}" | |
| BUTTONS="${BUTTONS}[{\"text\":\"💾 ${BASENAME}\",\"url\":\"${FILE_URL}\"}]," | |
| fi | |
| done < <(find "$ARTIFACTS_PATH" -type f) | |
| fi | |
| if [ -f "$PROJECT/Dockerfile" ]; then | |
| BUTTONS="${BUTTONS}[{\"text\":\"🐳 Docker image\",\"url\":\"https://hub.docker.com/r/${DOCKERHUB_USER}/${NAME}\"}]," | |
| fi | |
| HOMEPAGE=$(jq -r '.homepage // empty' "$PKG") | |
| if [ -n "$HOMEPAGE" ]; then | |
| BUTTONS="${BUTTONS}[{\"text\":\"🌐 Homepage\",\"url\":\"${HOMEPAGE}\"}]," | |
| fi | |
| BUTTONS="${BUTTONS}[{\"text\":\"📂 Project folder\",\"url\":\"${PROJECT_URL}\"}]," | |
| BUTTONS="${BUTTONS}[{\"text\":\"ℹ️ View release\",\"url\":\"${RELEASE_URL}\"}]" | |
| BUTTONS="${BUTTONS}]" | |
| BUTTONS=$(echo "$BUTTONS" | sed 's/,]/]/') | |
| echo "TG_BODY: $TG_BODY" | |
| echo "BUTTONS: $BUTTONS" | |
| # Отправка Telegram с обработкой ошибок | |
| if ! curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \ | |
| -d "chat_id=${{ vars.TELEGRAM_CHAT_ID }}" \ | |
| -d "message_thread_id=${{ vars.TELEGRAM_CHAT_THREAD_ID }}" \ | |
| -d "parse_mode=Markdown" \ | |
| -d "disable_web_page_preview=true" \ | |
| -d "text=${TG_BODY}" \ | |
| -d "reply_markup={\"inline_keyboard\":${BUTTONS}}"; then | |
| echo "⚠️ Telegram send failed!" | |
| echo "TG_BODY: $TG_BODY" | |
| echo "BUTTONS: $BUTTONS" | |
| fi | |
| fi | |
| done | |
| ```` | |
| ## File: ionic_capacitor/.gitignore | |
| ```` | |
| artifacts | |
| ```` | |
| ## File: ionic_capacitor/build-android.sh | |
| ````bash | |
| #!/bin/bash | |
| # Navigate to the app directory | |
| cd /app | |
| # Set Prisma engines mirror to avoid blocking issues | |
| export PRISMA_ENGINES_MIRROR=https://registry.npmmirror.com/-/binary/prisma | |
| # Check if node_modules exists, if not install dependencies | |
| if [ ! -d "node_modules" ]; then | |
| echo "Installing npm dependencies..." | |
| npm install | |
| fi | |
| # Disable telemetry | |
| npx cap telemetry off | |
| # Update capacitor config with environment variables if available | |
| # if [ -n "$KEYSTORE_PASSWORD" ] || [ -n "$KEYSTORE_ALIAS" ] || [ -n "$KEYSTORE_ALIAS_PASSWORD" ]; then | |
| echo "Updating capacitor.config.ts with environment variables..." | |
| node update-capacitor-config.js | |
| # fi | |
| # Check if www directory exists, if not build the project | |
| if [ ! -d "www" ] || [ -z "$(ls -A www)" ]; then | |
| echo "Building web assets..." | |
| ./node_modules/.bin/ionic build --prod | |
| fi | |
| echo "Adding Android platform..." | |
| # Add Android platform (this is safe even if already added) | |
| npx cap add android || echo "Android platform may already be added" | |
| echo "Syncing web code to Android platform..." | |
| # Sync the web code to the Android platform | |
| npx cap sync android | |
| # Check if keystore exists | |
| if [ ! -f "my-dashboard.jks" ]; then | |
| echo "Warning: Keystore file not found. Building debug APK instead." | |
| echo "Building Android app (debug)..." | |
| npx cap build android | |
| else | |
| echo "Building Android app (release)..." | |
| npx cap build android | |
| fi | |
| echo "Build process completed!" | |
| # List the output files | |
| echo "APK files generated:" | |
| ls -la android/app/build/outputs/apk/release/ | |
| ```` | |
| ## File: ionic_capacitor/Dockerfile | |
| ```` | |
| FROM ubuntu:22.04 | |
| LABEL MAINTAINER="Ilshat Khamitov <[email protected]>" | |
| ARG JAVA_VERSION=21 | |
| # See https://developer.android.com/studio/index.html#command-tools | |
| ARG ANDROID_SDK_VERSION=11076708 | |
| # See https://developer.android.com/tools/releases/build-tools | |
| ARG ANDROID_BUILD_TOOLS_VERSION=34.0.0 | |
| # See https://developer.android.com/studio/releases/platforms | |
| ARG ANDROID_PLATFORMS_VERSION=34 | |
| # See https://gradle.org/releases/ | |
| ARG GRADLE_VERSION=8.2.1 | |
| # See https://www.npmjs.com/package/@ionic/cli | |
| ARG IONIC_VERSION=7.2.0 | |
| # See https://www.npmjs.com/package/@capacitor/cli | |
| ARG CAPACITOR_VERSION=6.0.0 | |
| ENV DEBIAN_FRONTEND=noninteractive | |
| ENV LANG=en_US.UTF-8 | |
| ENV NODE_VERSION=23.11.0 | |
| ENV PRISMA_ENGINES_MIRROR=https://registry.npmmirror.com/-/binary/prisma | |
| WORKDIR /tmp | |
| RUN apt-get update -q | |
| # General packages | |
| RUN apt-get install -qy \ | |
| apt-utils \ | |
| locales \ | |
| gnupg2 \ | |
| build-essential \ | |
| curl \ | |
| usbutils \ | |
| git \ | |
| unzip \ | |
| p7zip p7zip-full \ | |
| python3 \ | |
| openjdk-${JAVA_VERSION}-jre \ | |
| openjdk-${JAVA_VERSION}-jdk | |
| # Set locale | |
| RUN locale-gen en_US.UTF-8 && update-locale | |
| # Install Gradle | |
| ENV GRADLE_HOME=/opt/gradle | |
| RUN mkdir $GRADLE_HOME \ | |
| && curl -sL https://services.gradle.org/distributions/gradle-${GRADLE_VERSION}-bin.zip -o gradle-${GRADLE_VERSION}-bin.zip \ | |
| && unzip -d $GRADLE_HOME gradle-${GRADLE_VERSION}-bin.zip | |
| ENV PATH=$PATH:/opt/gradle/gradle-${GRADLE_VERSION}/bin | |
| # Install Android SDK tools | |
| ENV ANDROID_HOME=/opt/android-sdk | |
| RUN curl -sL https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip -o commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip \ | |
| && unzip commandlinetools-linux-${ANDROID_SDK_VERSION}_latest.zip \ | |
| && mkdir $ANDROID_HOME && mv cmdline-tools $ANDROID_HOME \ | |
| && yes | $ANDROID_HOME/cmdline-tools/bin/sdkmanager --sdk_root=$ANDROID_HOME --licenses \ | |
| && $ANDROID_HOME/cmdline-tools/bin/sdkmanager --sdk_root=$ANDROID_HOME "platform-tools" "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" "platforms;android-${ANDROID_PLATFORMS_VERSION}" | |
| ENV PATH=$PATH:${ANDROID_HOME}/cmdline-tools:${ANDROID_HOME}/platform-tools | |
| ENV NVM_DIR=/root/.nvm | |
| # Install NodeJS | |
| RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.6/install.sh | bash \ | |
| && . $NVM_DIR/nvm.sh \ | |
| && nvm install $NODE_VERSION \ | |
| && nvm alias default $NODE_VERSION \ | |
| && nvm use default \ | |
| && ln -s $NVM_DIR/versions/node/v$NODE_VERSION/bin/node /usr/bin/node \ | |
| && ln -s $NVM_DIR/versions/node/v$NODE_VERSION/bin/npm /usr/bin/npm \ | |
| && ln -s $NVM_DIR/versions/node/v$NODE_VERSION/bin/npx /usr/bin/npx | |
| # Install Ionic CLI and Capacitor CLI | |
| RUN npm install -g @ionic/cli@${IONIC_VERSION} \ | |
| && npm install -g @capacitor/cli@${CAPACITOR_VERSION} | |
| # Create app directory | |
| RUN mkdir -p /app | |
| # Copy the build script | |
| COPY ./build-android.sh /usr/local/bin/build-android.sh | |
| RUN chmod +x /usr/local/bin/build-android.sh | |
| # Clean up | |
| RUN apt-get autoremove -y \ | |
| && apt-get clean -y \ | |
| && rm -rf /var/lib/apt/lists/* \ | |
| && rm -rf /tmp/* | |
| WORKDIR /app | |
| # Default command | |
| ENTRYPOINT ["/usr/local/bin/build-android.sh"] | |
| ```` | |
| ## File: ionic_capacitor/package.json | |
| ````json | |
| { | |
| "name": "ionic-capacitor", | |
| "version": "0.0.21", | |
| "description": "Docker image for building Ionic-Capacitor Android applications with automated APK generation and keystore management.", | |
| "author": "Ilshat Khamitov <[email protected]>" | |
| } | |
| ```` | |
| ## File: ionic_capacitor/README_RU.md | |
| ````markdown | |
| # Сборщик Docker для Ionic Capacitor | |
| Этот каталог содержит конфигурацию Docker для сборки образа ionic-capacitor. | |
| ## Репозиторий Docker Hub | |
| Образ Docker размещен на Docker Hub: | |
| [endykaufman/ionic-capacitor](https://hub.docker.com/repository/docker/endykaufman/ionic-capacitor/tags/latest) | |
| ## Сообщество | |
| Присоединяйтесь к нашему Telegram-чату разработчиков для обсуждений, обновлений и поддержки: | |
| - [Telegram-чат разработчиков](https://t.me/site15_community) | |
| ## Уведомления о релизах | |
| Информация о релизах и обновлениях автоматически публикуется в нашем Telegram-чате сообщества: | |
| - [Уведомления о релизах в Telegram](https://t.me/site15_community/3) | |
| ## Сборка образа Docker | |
| Для локальной сборки образа Docker выполните: | |
| ```bash | |
| docker build -t endykaufman/ionic-capacitor . | |
| ``` | |
| ## Публикация образа Docker | |
| Чтобы опубликовать образ Docker на Docker Hub: | |
| 1. Войдите в Docker Hub: | |
| ```bash | |
| docker login | |
| ``` | |
| 2. Пометьте образ вашим именем пользователя на Docker Hub: | |
| ```bash | |
| docker tag endykaufman/ionic-capacitor your-dockerhub-username/ionic-capacitor:latest | |
| ``` | |
| 3. Отправьте образ в Docker Hub: | |
| ```bash | |
| docker push your-dockerhub-username/ionic-capacitor:latest | |
| ``` | |
| Для автоматических сборок вы также можете использовать функцию автоматической сборки Docker Hub, подключив репозиторий GitHub. | |
| ## Детали образа Docker | |
| Этот образ Docker содержит все необходимые инструменты и зависимости для сборки Android-приложений Ionic Capacitor: | |
| - Базовый образ Ubuntu 22.04 | |
| - OpenJDK 21 | |
| - Android SDK и инструменты сборки | |
| - Node.js 23.11.0 | |
| - Ionic CLI и Capacitor CLI | |
| - Gradle 8.2.1 | |
| Образ предназначен для использования с монтированием томов для сборки Android-приложений в каталоге mobile. | |
| Инструкции по использованию этого контейнера для сборки Android-приложений находятся в документации мобильного проекта: | |
| - [Английская документация](../mobile/README.md) | |
| - [Русская документация](../mobile/README_RU.md) | |
| ```` | |
| ## File: ionic_capacitor/README.md | |
| ````markdown | |
| # Ionic Capacitor Docker Builder | |
| This directory contains the Docker configuration for building the ionic-capacitor Docker image. | |
| ## Docker Hub Repository | |
| The Docker image is hosted on Docker Hub: | |
| [endykaufman/ionic-capacitor](https://hub.docker.com/repository/docker/endykaufman/ionic-capacitor/tags/latest) | |
| ## Community | |
| Join our Telegram developer community for discussions, updates, and support: | |
| - [Telegram Developer Chat](https://t.me/site15_community) | |
| ## Release Notifications | |
| Release information and updates are automatically posted to our Telegram community chat: | |
| - [Telegram Release Notifications](https://t.me/site15_community/3) | |
| ## Building the Docker Image | |
| To build the Docker image locally: | |
| ```bash | |
| docker build -t endykaufman/ionic-capacitor . | |
| ``` | |
| ## Publishing the Docker Image | |
| To publish the Docker image to Docker Hub: | |
| 1. Login to Docker Hub: | |
| ```bash | |
| docker login | |
| ``` | |
| 2. Tag the image with your Docker Hub username: | |
| ```bash | |
| docker tag endykaufman/ionic-capacitor your-dockerhub-username/ionic-capacitor:latest | |
| ``` | |
| 3. Push the image to Docker Hub: | |
| ```bash | |
| docker push your-dockerhub-username/ionic-capacitor:latest | |
| ``` | |
| For automated builds, you can also use Docker Hub's automated build feature by connecting your GitHub repository. | |
| ## Docker Image Details | |
| This Docker image contains all the necessary tools and dependencies to build Ionic Capacitor Android applications: | |
| - Ubuntu 22.04 base image | |
| - OpenJDK 21 | |
| - Android SDK and build tools | |
| - Node.js 23.11.0 | |
| - Ionic CLI and Capacitor CLI | |
| - Gradle 8.2.1 | |
| The image is designed to be used with volume mounting to build Android applications in the mobile directory. | |
| For instructions on how to use this container to build Android applications, please refer to the mobile project documentation: | |
| - [English Documentation](../mobile/README.md) | |
| - [Russian Documentation](../mobile/README_RU.md) | |
| ```` | |
| ## File: mobile/.vscode/extensions.json | |
| ````json | |
| { | |
| "recommendations": [ | |
| "Webnative.webnative" | |
| ] | |
| } | |
| ```` | |
| ## File: mobile/.vscode/settings.json | |
| ````json | |
| { | |
| "typescript.preferences.autoImportFileExcludePatterns": ["@ionic/angular/common", "@ionic/angular"] | |
| } | |
| ```` | |
| ## File: mobile/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java | |
| ````java | |
| package com.getcapacitor.myapp; | |
| import static org.junit.Assert.*; | |
| import android.content.Context; | |
| import androidx.test.ext.junit.runners.AndroidJUnit4; | |
| import androidx.test.platform.app.InstrumentationRegistry; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| /** | |
| * Instrumented test, which will execute on an Android device. | |
| * | |
| * @see <a href="http://d.android.com/tools/testing">Testing documentation</a> | |
| */ | |
| @RunWith(AndroidJUnit4.class) | |
| public class ExampleInstrumentedTest { | |
| @Test | |
| public void useAppContext() throws Exception { | |
| // Context of the app under test. | |
| Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); | |
| assertEquals("com.getcapacitor.app", appContext.getPackageName()); | |
| } | |
| } | |
| ```` | |
| ## File: mobile/android/app/src/main/java/ru/site15/MyDashboard/MainActivity.java | |
| ````java | |
| package ru.site15.MyDashboard; | |
| import com.getcapacitor.BridgeActivity; | |
| public class MainActivity extends BridgeActivity {} | |
| ```` | |
| ## File: mobile/android/app/src/main/res/drawable/ic_launcher_background.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <vector xmlns:android="http://schemas.android.com/apk/res/android" | |
| android:width="108dp" | |
| android:height="108dp" | |
| android:viewportHeight="108" | |
| android:viewportWidth="108"> | |
| <path | |
| android:fillColor="#26A69A" | |
| android:pathData="M0,0h108v108h-108z" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M9,0L9,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,0L19,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M29,0L29,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M39,0L39,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M49,0L49,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M59,0L59,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M69,0L69,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M79,0L79,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M89,0L89,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M99,0L99,108" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,9L108,9" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,19L108,19" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,29L108,29" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,39L108,39" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,49L108,49" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,59L108,59" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,69L108,69" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,79L108,79" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,89L108,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M0,99L108,99" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,29L89,29" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,39L89,39" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,49L89,49" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,59L89,59" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,69L89,69" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M19,79L89,79" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M29,19L29,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M39,19L39,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M49,19L49,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M59,19L59,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M69,19L69,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| <path | |
| android:fillColor="#00000000" | |
| android:pathData="M79,19L79,89" | |
| android:strokeColor="#33FFFFFF" | |
| android:strokeWidth="0.8" /> | |
| </vector> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml | |
| ````xml | |
| <vector xmlns:android="http://schemas.android.com/apk/res/android" | |
| xmlns:aapt="http://schemas.android.com/aapt" | |
| android:width="108dp" | |
| android:height="108dp" | |
| android:viewportHeight="108" | |
| android:viewportWidth="108"> | |
| <path | |
| android:fillType="evenOdd" | |
| android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z" | |
| android:strokeColor="#00000000" | |
| android:strokeWidth="1"> | |
| <aapt:attr name="android:fillColor"> | |
| <gradient | |
| android:endX="78.5885" | |
| android:endY="90.9159" | |
| android:startX="48.7653" | |
| android:startY="61.0927" | |
| android:type="linear"> | |
| <item | |
| android:color="#44000000" | |
| android:offset="0.0" /> | |
| <item | |
| android:color="#00000000" | |
| android:offset="1.0" /> | |
| </gradient> | |
| </aapt:attr> | |
| </path> | |
| <path | |
| android:fillColor="#FFFFFF" | |
| android:fillType="nonZero" | |
| android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z" | |
| android:strokeColor="#00000000" | |
| android:strokeWidth="1" /> | |
| </vector> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/layout/activity_main.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android" | |
| xmlns:app="http://schemas.android.com/apk/res-auto" | |
| xmlns:tools="http://schemas.android.com/tools" | |
| android:layout_width="match_parent" | |
| android:layout_height="match_parent" | |
| tools:context=".MainActivity"> | |
| <WebView | |
| android:layout_width="match_parent" | |
| android:layout_height="match_parent" /> | |
| </androidx.coordinatorlayout.widget.CoordinatorLayout> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android"> | |
| <background android:drawable="@color/ic_launcher_background"/> | |
| <foreground android:drawable="@mipmap/ic_launcher_foreground"/> | |
| </adaptive-icon> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android"> | |
| <background android:drawable="@color/ic_launcher_background"/> | |
| <foreground android:drawable="@mipmap/ic_launcher_foreground"/> | |
| </adaptive-icon> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/values/ic_launcher_background.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <resources> | |
| <color name="ic_launcher_background">#FFFFFF</color> | |
| </resources> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/values/strings.xml | |
| ````xml | |
| <?xml version='1.0' encoding='utf-8'?> | |
| <resources> | |
| <string name="app_name">MyDashboard</string> | |
| <string name="title_activity_main">MyDashboard</string> | |
| <string name="package_name">ru.site15.MyDashboard</string> | |
| <string name="custom_url_scheme">ru.site15.MyDashboard</string> | |
| </resources> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/values/styles.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <resources> | |
| <!-- Base application theme. --> | |
| <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar"> | |
| <!-- Customize your theme here. --> | |
| <item name="colorPrimary">@color/colorPrimary</item> | |
| <item name="colorPrimaryDark">@color/colorPrimaryDark</item> | |
| <item name="colorAccent">@color/colorAccent</item> | |
| </style> | |
| <style name="AppTheme.NoActionBar" parent="Theme.AppCompat.DayNight.NoActionBar"> | |
| <item name="windowActionBar">false</item> | |
| <item name="windowNoTitle">true</item> | |
| <item name="android:background">@null</item> | |
| </style> | |
| <style name="AppTheme.NoActionBarLaunch" parent="Theme.SplashScreen"> | |
| <item name="android:background">@drawable/splash</item> | |
| </style> | |
| </resources> | |
| ```` | |
| ## File: mobile/android/app/src/main/res/xml/file_paths.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <paths xmlns:android="http://schemas.android.com/apk/res/android"> | |
| <external-path name="my_images" path="." /> | |
| <cache-path name="my_cache_images" path="." /> | |
| </paths> | |
| ```` | |
| ## File: mobile/android/app/src/main/AndroidManifest.xml | |
| ````xml | |
| <?xml version="1.0" encoding="utf-8"?> | |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android"> | |
| <application | |
| android:allowBackup="true" | |
| android:icon="@mipmap/ic_launcher" | |
| android:label="@string/app_name" | |
| android:roundIcon="@mipmap/ic_launcher_round" | |
| android:supportsRtl="true" | |
| android:theme="@style/AppTheme"> | |
| <activity | |
| android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation" | |
| android:name=".MainActivity" | |
| android:label="@string/title_activity_main" | |
| android:theme="@style/AppTheme.NoActionBarLaunch" | |
| android:launchMode="singleTask" | |
| android:exported="true"> | |
| <intent-filter> | |
| <action android:name="android.intent.action.MAIN" /> | |
| <category android:name="android.intent.category.LAUNCHER" /> | |
| </intent-filter> | |
| </activity> | |
| <provider | |
| android:name="androidx.core.content.FileProvider" | |
| android:authorities="${applicationId}.fileprovider" | |
| android:exported="false" | |
| android:grantUriPermissions="true"> | |
| <meta-data | |
| android:name="android.support.FILE_PROVIDER_PATHS" | |
| android:resource="@xml/file_paths"></meta-data> | |
| </provider> | |
| </application> | |
| <!-- Permissions --> | |
| <uses-permission android:name="android.permission.INTERNET" /> | |
| </manifest> | |
| ```` | |
| ## File: mobile/android/app/src/test/java/com/getcapacitor/myapp/ExampleUnitTest.java | |
| ````java | |
| package com.getcapacitor.myapp; | |
| import static org.junit.Assert.*; | |
| import org.junit.Test; | |
| /** | |
| * Example local unit test, which will execute on the development machine (host). | |
| * | |
| * @see <a href="http://d.android.com/tools/testing">Testing documentation</a> | |
| */ | |
| public class ExampleUnitTest { | |
| @Test | |
| public void addition_isCorrect() throws Exception { | |
| assertEquals(4, 2 + 2); | |
| } | |
| } | |
| ```` | |
| ## File: mobile/android/app/.gitignore | |
| ```` | |
| /build/* | |
| !/build/.npmkeep | |
| ```` | |
| ## File: mobile/android/app/build.gradle | |
| ```` | |
| apply plugin: 'com.android.application' | |
| android { | |
| namespace "ru.site15.MyDashboard" | |
| compileSdk rootProject.ext.compileSdkVersion | |
| defaultConfig { | |
| applicationId "ru.site15.MyDashboard" | |
| minSdkVersion rootProject.ext.minSdkVersion | |
| targetSdkVersion rootProject.ext.targetSdkVersion | |
| versionCode 1 | |
| versionName "1.0" | |
| testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" | |
| aaptOptions { | |
| // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps. | |
| // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61 | |
| ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~' | |
| } | |
| } | |
| buildTypes { | |
| release { | |
| minifyEnabled false | |
| proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' | |
| } | |
| } | |
| } | |
| repositories { | |
| flatDir{ | |
| dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs' | |
| } | |
| } | |
| dependencies { | |
| implementation fileTree(include: ['*.jar'], dir: 'libs') | |
| implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion" | |
| implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion" | |
| implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion" | |
| implementation project(':capacitor-android') | |
| testImplementation "junit:junit:$junitVersion" | |
| androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion" | |
| androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion" | |
| implementation project(':capacitor-cordova-android-plugins') | |
| } | |
| apply from: 'capacitor.build.gradle' | |
| try { | |
| def servicesJSON = file('google-services.json') | |
| if (servicesJSON.text) { | |
| apply plugin: 'com.google.gms.google-services' | |
| } | |
| } catch(Exception e) { | |
| logger.info("google-services.json not found, google-services plugin not applied. Push Notifications won't work") | |
| } | |
| ```` | |
| ## File: mobile/android/app/capacitor.build.gradle | |
| ```` | |
| // DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN | |
| android { | |
| compileOptions { | |
| sourceCompatibility JavaVersion.VERSION_21 | |
| targetCompatibility JavaVersion.VERSION_21 | |
| } | |
| } | |
| apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle" | |
| dependencies { | |
| implementation project(':capacitor-app') | |
| implementation project(':capacitor-haptics') | |
| implementation project(':capacitor-keyboard') | |
| implementation project(':capacitor-status-bar') | |
| } | |
| if (hasProperty('postBuildExtras')) { | |
| postBuildExtras() | |
| } | |
| ```` | |
| ## File: mobile/android/app/proguard-rules.pro | |
| ```` | |
| # Add project specific ProGuard rules here. | |
| # You can control the set of applied configuration files using the | |
| # proguardFiles setting in build.gradle. | |
| # | |
| # For more details, see | |
| # http://developer.android.com/guide/developing/tools/proguard.html | |
| # If your project uses WebView with JS, uncomment the following | |
| # and specify the fully qualified class name to the JavaScript interface | |
| # class: | |
| #-keepclassmembers class fqcn.of.javascript.interface.for.webview { | |
| # public *; | |
| #} | |
| # Uncomment this to preserve the line number information for | |
| # debugging stack traces. | |
| #-keepattributes SourceFile,LineNumberTable | |
| # If you keep the line number information, uncomment this to | |
| # hide the original source file name. | |
| #-renamesourcefileattribute SourceFile | |
| ```` | |
| ## File: mobile/android/gradle/wrapper/gradle-wrapper.properties | |
| ```` | |
| distributionBase=GRADLE_USER_HOME | |
| distributionPath=wrapper/dists | |
| distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-all.zip | |
| networkTimeout=10000 | |
| validateDistributionUrl=true | |
| zipStoreBase=GRADLE_USER_HOME | |
| zipStorePath=wrapper/dists | |
| ```` | |
| ## File: mobile/android/.gitignore | |
| ```` | |
| # Using Android gitignore template: https://github.com/github/gitignore/blob/HEAD/Android.gitignore | |
| # Built application files | |
| *.apk | |
| *.aar | |
| *.ap_ | |
| *.aab | |
| # Files for the ART/Dalvik VM | |
| *.dex | |
| # Java class files | |
| *.class | |
| # Generated files | |
| bin/ | |
| gen/ | |
| out/ | |
| # Uncomment the following line in case you need and you don't have the release build type files in your app | |
| # release/ | |
| # Gradle files | |
| .gradle/ | |
| build/ | |
| # Local configuration file (sdk path, etc) | |
| local.properties | |
| # Proguard folder generated by Eclipse | |
| proguard/ | |
| # Log Files | |
| *.log | |
| # Android Studio Navigation editor temp files | |
| .navigation/ | |
| # Android Studio captures folder | |
| captures/ | |
| # IntelliJ | |
| *.iml | |
| .idea/workspace.xml | |
| .idea/tasks.xml | |
| .idea/gradle.xml | |
| .idea/assetWizardSettings.xml | |
| .idea/dictionaries | |
| .idea/libraries | |
| # Android Studio 3 in .gitignore file. | |
| .idea/caches | |
| .idea/modules.xml | |
| # Comment next line if keeping position of elements in Navigation Editor is relevant for you | |
| .idea/navEditor.xml | |
| # Keystore files | |
| # Uncomment the following lines if you do not want to check your keystore files in. | |
| #*.jks | |
| #*.keystore | |
| # External native build folder generated in Android Studio 2.2 and later | |
| .externalNativeBuild | |
| .cxx/ | |
| # Google Services (e.g. APIs or Firebase) | |
| # google-services.json | |
| # Freeline | |
| freeline.py | |
| freeline/ | |
| freeline_project_description.json | |
| # fastlane | |
| fastlane/report.xml | |
| fastlane/Preview.html | |
| fastlane/screenshots | |
| fastlane/test_output | |
| fastlane/readme.md | |
| # Version control | |
| vcs.xml | |
| # lint | |
| lint/intermediates/ | |
| lint/generated/ | |
| lint/outputs/ | |
| lint/tmp/ | |
| # lint/reports/ | |
| # Android Profiling | |
| *.hprof | |
| # Cordova plugins for Capacitor | |
| capacitor-cordova-android-plugins | |
| # Copied web assets | |
| app/src/main/assets/public | |
| # Generated Config files | |
| app/src/main/assets/capacitor.config.json | |
| app/src/main/assets/capacitor.plugins.json | |
| app/src/main/res/xml/config.xml | |
| ```` | |
| ## File: mobile/android/build.gradle | |
| ```` | |
| // Top-level build file where you can add configuration options common to all sub-projects/modules. | |
| buildscript { | |
| repositories { | |
| google() | |
| mavenCentral() | |
| } | |
| dependencies { | |
| classpath 'com.android.tools.build:gradle:8.7.2' | |
| classpath 'com.google.gms:google-services:4.4.2' | |
| // NOTE: Do not place your application dependencies here; they belong | |
| // in the individual module build.gradle files | |
| } | |
| } | |
| apply from: "variables.gradle" | |
| allprojects { | |
| repositories { | |
| google() | |
| mavenCentral() | |
| } | |
| } | |
| task clean(type: Delete) { | |
| delete rootProject.buildDir | |
| } | |
| ```` | |
| ## File: mobile/android/capacitor.settings.gradle | |
| ```` | |
| // DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN | |
| include ':capacitor-android' | |
| project(':capacitor-android').projectDir = new File('../node_modules/@capacitor/android/capacitor') | |
| include ':capacitor-app' | |
| project(':capacitor-app').projectDir = new File('../node_modules/@capacitor/app/android') | |
| include ':capacitor-haptics' | |
| project(':capacitor-haptics').projectDir = new File('../node_modules/@capacitor/haptics/android') | |
| include ':capacitor-keyboard' | |
| project(':capacitor-keyboard').projectDir = new File('../node_modules/@capacitor/keyboard/android') | |
| include ':capacitor-status-bar' | |
| project(':capacitor-status-bar').projectDir = new File('../node_modules/@capacitor/status-bar/android') | |
| ```` | |
| ## File: mobile/android/gradle.properties | |
| ```` | |
| # Project-wide Gradle settings. | |
| # IDE (e.g. Android Studio) users: | |
| # Gradle settings configured through the IDE *will override* | |
| # any settings specified in this file. | |
| # For more details on how to configure your build environment visit | |
| # http://www.gradle.org/docs/current/userguide/build_environment.html | |
| # Specifies the JVM arguments used for the daemon process. | |
| # The setting is particularly useful for tweaking memory settings. | |
| org.gradle.jvmargs=-Xmx1536m | |
| # When configured, Gradle will run in incubating parallel mode. | |
| # This option should only be used with decoupled projects. More details, visit | |
| # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects | |
| # org.gradle.parallel=true | |
| # AndroidX package structure to make it clearer which packages are bundled with the | |
| # Android operating system, and which are packaged with your app's APK | |
| # https://developer.android.com/topic/libraries/support-library/androidx-rn | |
| android.useAndroidX=true | |
| ```` | |
| ## File: mobile/android/gradlew | |
| ```` | |
| #!/bin/sh | |
| # | |
| # Copyright © 2015-2021 the original authors. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # https://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| # | |
| # SPDX-License-Identifier: Apache-2.0 | |
| # | |
| ############################################################################## | |
| # | |
| # Gradle start up script for POSIX generated by Gradle. | |
| # | |
| # Important for running: | |
| # | |
| # (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is | |
| # noncompliant, but you have some other compliant shell such as ksh or | |
| # bash, then to run this script, type that shell name before the whole | |
| # command line, like: | |
| # | |
| # ksh Gradle | |
| # | |
| # Busybox and similar reduced shells will NOT work, because this script | |
| # requires all of these POSIX shell features: | |
| # * functions; | |
| # * expansions «$var», «${var}», «${var:-default}», «${var+SET}», | |
| # «${var#prefix}», «${var%suffix}», and «$( cmd )»; | |
| # * compound commands having a testable exit status, especially «case»; | |
| # * various built-in commands including «command», «set», and «ulimit». | |
| # | |
| # Important for patching: | |
| # | |
| # (2) This script targets any POSIX shell, so it avoids extensions provided | |
| # by Bash, Ksh, etc; in particular arrays are avoided. | |
| # | |
| # The "traditional" practice of packing multiple parameters into a | |
| # space-separated string is a well documented source of bugs and security | |
| # problems, so this is (mostly) avoided, by progressively accumulating | |
| # options in "$@", and eventually passing that to Java. | |
| # | |
| # Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, | |
| # and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; | |
| # see the in-line comments for details. | |
| # | |
| # There are tweaks for specific operating systems such as AIX, CygWin, | |
| # Darwin, MinGW, and NonStop. | |
| # | |
| # (3) This script is generated from the Groovy template | |
| # https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt | |
| # within the Gradle project. | |
| # | |
| # You can find Gradle at https://github.com/gradle/gradle/. | |
| # | |
| ############################################################################## | |
| # Attempt to set APP_HOME | |
| # Resolve links: $0 may be a link | |
| app_path=$0 | |
| # Need this for daisy-chained symlinks. | |
| while | |
| APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path | |
| [ -h "$app_path" ] | |
| do | |
| ls=$( ls -ld "$app_path" ) | |
| link=${ls#*' -> '} | |
| case $link in #( | |
| /*) app_path=$link ;; #( | |
| *) app_path=$APP_HOME$link ;; | |
| esac | |
| done | |
| # This is normally unused | |
| # shellcheck disable=SC2034 | |
| APP_BASE_NAME=${0##*/} | |
| # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) | |
| APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s | |
| ' "$PWD" ) || exit | |
| # Use the maximum available, or set MAX_FD != -1 to use that value. | |
| MAX_FD=maximum | |
| warn () { | |
| echo "$*" | |
| } >&2 | |
| die () { | |
| echo | |
| echo "$*" | |
| echo | |
| exit 1 | |
| } >&2 | |
| # OS specific support (must be 'true' or 'false'). | |
| cygwin=false | |
| msys=false | |
| darwin=false | |
| nonstop=false | |
| case "$( uname )" in #( | |
| CYGWIN* ) cygwin=true ;; #( | |
| Darwin* ) darwin=true ;; #( | |
| MSYS* | MINGW* ) msys=true ;; #( | |
| NONSTOP* ) nonstop=true ;; | |
| esac | |
| CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar | |
| # Determine the Java command to use to start the JVM. | |
| if [ -n "$JAVA_HOME" ] ; then | |
| if [ -x "$JAVA_HOME/jre/sh/java" ] ; then | |
| # IBM's JDK on AIX uses strange locations for the executables | |
| JAVACMD=$JAVA_HOME/jre/sh/java | |
| else | |
| JAVACMD=$JAVA_HOME/bin/java | |
| fi | |
| if [ ! -x "$JAVACMD" ] ; then | |
| die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME | |
| Please set the JAVA_HOME variable in your environment to match the | |
| location of your Java installation." | |
| fi | |
| else | |
| JAVACMD=java | |
| if ! command -v java >/dev/null 2>&1 | |
| then | |
| die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. | |
| Please set the JAVA_HOME variable in your environment to match the | |
| location of your Java installation." | |
| fi | |
| fi | |
| # Increase the maximum file descriptors if we can. | |
| if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then | |
| case $MAX_FD in #( | |
| max*) | |
| # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. | |
| # shellcheck disable=SC2039,SC3045 | |
| MAX_FD=$( ulimit -H -n ) || | |
| warn "Could not query maximum file descriptor limit" | |
| esac | |
| case $MAX_FD in #( | |
| '' | soft) :;; #( | |
| *) | |
| # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. | |
| # shellcheck disable=SC2039,SC3045 | |
| ulimit -n "$MAX_FD" || | |
| warn "Could not set maximum file descriptor limit to $MAX_FD" | |
| esac | |
| fi | |
| # Collect all arguments for the java command, stacking in reverse order: | |
| # * args from the command line | |
| # * the main class name | |
| # * -classpath | |
| # * -D...appname settings | |
| # * --module-path (only if needed) | |
| # * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. | |
| # For Cygwin or MSYS, switch paths to Windows format before running java | |
| if "$cygwin" || "$msys" ; then | |
| APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) | |
| CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) | |
| JAVACMD=$( cygpath --unix "$JAVACMD" ) | |
| # Now convert the arguments - kludge to limit ourselves to /bin/sh | |
| for arg do | |
| if | |
| case $arg in #( | |
| -*) false ;; # don't mess with options #( | |
| /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath | |
| [ -e "$t" ] ;; #( | |
| *) false ;; | |
| esac | |
| then | |
| arg=$( cygpath --path --ignore --mixed "$arg" ) | |
| fi | |
| # Roll the args list around exactly as many times as the number of | |
| # args, so each arg winds up back in the position where it started, but | |
| # possibly modified. | |
| # | |
| # NB: a `for` loop captures its iteration list before it begins, so | |
| # changing the positional parameters here affects neither the number of | |
| # iterations, nor the values presented in `arg`. | |
| shift # remove old arg | |
| set -- "$@" "$arg" # push replacement arg | |
| done | |
| fi | |
| # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. | |
| DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' | |
| # Collect all arguments for the java command: | |
| # * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, | |
| # and any embedded shellness will be escaped. | |
| # * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be | |
| # treated as '${Hostname}' itself on the command line. | |
| set -- \ | |
| "-Dorg.gradle.appname=$APP_BASE_NAME" \ | |
| -classpath "$CLASSPATH" \ | |
| org.gradle.wrapper.GradleWrapperMain \ | |
| "$@" | |
| # Stop when "xargs" is not available. | |
| if ! command -v xargs >/dev/null 2>&1 | |
| then | |
| die "xargs is not available" | |
| fi | |
| # Use "xargs" to parse quoted args. | |
| # | |
| # With -n1 it outputs one arg per line, with the quotes and backslashes removed. | |
| # | |
| # In Bash we could simply go: | |
| # | |
| # readarray ARGS < <( xargs -n1 <<<"$var" ) && | |
| # set -- "${ARGS[@]}" "$@" | |
| # | |
| # but POSIX shell has neither arrays nor command substitution, so instead we | |
| # post-process each arg (as a line of input to sed) to backslash-escape any | |
| # character that might be a shell metacharacter, then use eval to reverse | |
| # that process (while maintaining the separation between arguments), and wrap | |
| # the whole thing up as a single "set" statement. | |
| # | |
| # This will of course break if any of these variables contains a newline or | |
| # an unmatched quote. | |
| # | |
| eval "set -- $( | |
| printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | | |
| xargs -n1 | | |
| sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | | |
| tr '\n' ' ' | |
| )" '"$@"' | |
| exec "$JAVACMD" "$@" | |
| ```` | |
| ## File: mobile/android/gradlew.bat | |
| ```` | |
| @rem | |
| @rem Copyright 2015 the original author or authors. | |
| @rem | |
| @rem Licensed under the Apache License, Version 2.0 (the "License"); | |
| @rem you may not use this file except in compliance with the License. | |
| @rem You may obtain a copy of the License at | |
| @rem | |
| @rem https://www.apache.org/licenses/LICENSE-2.0 | |
| @rem | |
| @rem Unless required by applicable law or agreed to in writing, software | |
| @rem distributed under the License is distributed on an "AS IS" BASIS, | |
| @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| @rem See the License for the specific language governing permissions and | |
| @rem limitations under the License. | |
| @rem | |
| @rem SPDX-License-Identifier: Apache-2.0 | |
| @rem | |
| @if "%DEBUG%"=="" @echo off | |
| @rem ########################################################################## | |
| @rem | |
| @rem Gradle startup script for Windows | |
| @rem | |
| @rem ########################################################################## | |
| @rem Set local scope for the variables with windows NT shell | |
| if "%OS%"=="Windows_NT" setlocal | |
| set DIRNAME=%~dp0 | |
| if "%DIRNAME%"=="" set DIRNAME=. | |
| @rem This is normally unused | |
| set APP_BASE_NAME=%~n0 | |
| set APP_HOME=%DIRNAME% | |
| @rem Resolve any "." and ".." in APP_HOME to make it shorter. | |
| for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi | |
| @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. | |
| set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" | |
| @rem Find java.exe | |
| if defined JAVA_HOME goto findJavaFromJavaHome | |
| set JAVA_EXE=java.exe | |
| %JAVA_EXE% -version >NUL 2>&1 | |
| if %ERRORLEVEL% equ 0 goto execute | |
| echo. 1>&2 | |
| echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 | |
| echo. 1>&2 | |
| echo Please set the JAVA_HOME variable in your environment to match the 1>&2 | |
| echo location of your Java installation. 1>&2 | |
| goto fail | |
| :findJavaFromJavaHome | |
| set JAVA_HOME=%JAVA_HOME:"=% | |
| set JAVA_EXE=%JAVA_HOME%/bin/java.exe | |
| if exist "%JAVA_EXE%" goto execute | |
| echo. 1>&2 | |
| echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 | |
| echo. 1>&2 | |
| echo Please set the JAVA_HOME variable in your environment to match the 1>&2 | |
| echo location of your Java installation. 1>&2 | |
| goto fail | |
| :execute | |
| @rem Setup the command line | |
| set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar | |
| @rem Execute Gradle | |
| "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* | |
| :end | |
| @rem End local scope for the variables with windows NT shell | |
| if %ERRORLEVEL% equ 0 goto mainEnd | |
| :fail | |
| rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of | |
| rem the _cmd.exe /c_ return code! | |
| set EXIT_CODE=%ERRORLEVEL% | |
| if %EXIT_CODE% equ 0 set EXIT_CODE=1 | |
| if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% | |
| exit /b %EXIT_CODE% | |
| :mainEnd | |
| if "%OS%"=="Windows_NT" endlocal | |
| :omega | |
| ```` | |
| ## File: mobile/android/settings.gradle | |
| ```` | |
| include ':app' | |
| include ':capacitor-cordova-android-plugins' | |
| project(':capacitor-cordova-android-plugins').projectDir = new File('./capacitor-cordova-android-plugins/') | |
| apply from: 'capacitor.settings.gradle' | |
| ```` | |
| ## File: mobile/android/variables.gradle | |
| ```` | |
| ext { | |
| minSdkVersion = 24 | |
| compileSdkVersion = 35 | |
| targetSdkVersion = 24 | |
| androidxActivityVersion = '1.9.2' | |
| androidxAppCompatVersion = '1.7.0' | |
| androidxCoordinatorLayoutVersion = '1.2.0' | |
| androidxCoreVersion = '1.15.0' | |
| androidxFragmentVersion = '1.8.4' | |
| coreSplashScreenVersion = '1.0.1' | |
| androidxWebkitVersion = '1.12.1' | |
| junitVersion = '4.13.2' | |
| androidxJunitVersion = '1.2.1' | |
| androidxEspressoCoreVersion = '3.6.1' | |
| cordovaAndroidVersion = '10.1.1' | |
| } | |
| ```` | |
| ## File: mobile/src/app/explore-container/explore-container.component.html | |
| ````html | |
| <div id="container"> | |
| <strong>{{ name }}</strong> | |
| <p> | |
| Explore | |
| <a | |
| target="_blank" | |
| rel="noopener noreferrer" | |
| href="https://ionicframework.com/docs/components" | |
| >UI Components</a | |
| > | |
| </p> | |
| </div> | |
| ```` | |
| ## File: mobile/src/app/explore-container/explore-container.component.scss | |
| ````scss | |
| #container { | |
| text-align: center; | |
| position: absolute; | |
| left: 0; | |
| right: 0; | |
| top: 50%; | |
| transform: translateY(-50%); | |
| } | |
| #container strong { | |
| font-size: 20px; | |
| line-height: 26px; | |
| } | |
| #container p { | |
| font-size: 16px; | |
| line-height: 22px; | |
| color: #8c8c8c; | |
| margin: 0; | |
| } | |
| #container a { | |
| text-decoration: none; | |
| } | |
| ```` | |
| ## File: mobile/src/app/explore-container/explore-container.component.spec.ts | |
| ````typescript | |
| import { ComponentFixture, TestBed } from '@angular/core/testing'; | |
| import { ExploreContainerComponent } from './explore-container.component'; | |
| describe('ExploreContainerComponent', () => { | |
| let component: ExploreContainerComponent; | |
| let fixture: ComponentFixture<ExploreContainerComponent>; | |
| beforeEach(async () => { | |
| fixture = TestBed.createComponent(ExploreContainerComponent); | |
| component = fixture.componentInstance; | |
| fixture.detectChanges(); | |
| }); | |
| it('should create', () => { | |
| expect(component).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/explore-container/explore-container.component.ts | |
| ````typescript | |
| import { Component, Input } from '@angular/core'; | |
| @Component({ | |
| selector: 'app-explore-container', | |
| templateUrl: './explore-container.component.html', | |
| styleUrls: ['./explore-container.component.scss'], | |
| }) | |
| export class ExploreContainerComponent { | |
| @Input() name?: string; | |
| } | |
| ```` | |
| ## File: mobile/src/app/tab1/tab1.page.html | |
| ````html | |
| <ion-header [translucent]="true"> | |
| <ion-toolbar> | |
| <ion-title> | |
| Tab 1 | |
| </ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <ion-content [fullscreen]="true"> | |
| <ion-header collapse="condense"> | |
| <ion-toolbar> | |
| <ion-title size="large">Tab 1</ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <app-explore-container name="Tab 1 page"></app-explore-container> | |
| </ion-content> | |
| ```` | |
| ## File: mobile/src/app/tab1/tab1.page.spec.ts | |
| ````typescript | |
| import { ComponentFixture, TestBed } from '@angular/core/testing'; | |
| import { Tab1Page } from './tab1.page'; | |
| describe('Tab1Page', () => { | |
| let component: Tab1Page; | |
| let fixture: ComponentFixture<Tab1Page>; | |
| beforeEach(async () => { | |
| fixture = TestBed.createComponent(Tab1Page); | |
| component = fixture.componentInstance; | |
| fixture.detectChanges(); | |
| }); | |
| it('should create', () => { | |
| expect(component).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/tab1/tab1.page.ts | |
| ````typescript | |
| import { Component } from '@angular/core'; | |
| import { IonHeader, IonToolbar, IonTitle, IonContent } from '@ionic/angular/standalone'; | |
| import { ExploreContainerComponent } from '../explore-container/explore-container.component'; | |
| @Component({ | |
| selector: 'app-tab1', | |
| templateUrl: 'tab1.page.html', | |
| styleUrls: ['tab1.page.scss'], | |
| imports: [IonHeader, IonToolbar, IonTitle, IonContent, ExploreContainerComponent], | |
| }) | |
| export class Tab1Page { | |
| constructor() {} | |
| } | |
| ```` | |
| ## File: mobile/src/app/tab2/tab2.page.html | |
| ````html | |
| <ion-header [translucent]="true"> | |
| <ion-toolbar> | |
| <ion-title> | |
| Tab 2 | |
| </ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <ion-content [fullscreen]="true"> | |
| <ion-header collapse="condense"> | |
| <ion-toolbar> | |
| <ion-title size="large">Tab 2</ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <app-explore-container name="Tab 2 page"></app-explore-container> | |
| </ion-content> | |
| ```` | |
| ## File: mobile/src/app/tab2/tab2.page.spec.ts | |
| ````typescript | |
| import { ComponentFixture, TestBed } from '@angular/core/testing'; | |
| import { Tab2Page } from './tab2.page'; | |
| describe('Tab2Page', () => { | |
| let component: Tab2Page; | |
| let fixture: ComponentFixture<Tab2Page>; | |
| beforeEach(async () => { | |
| fixture = TestBed.createComponent(Tab2Page); | |
| component = fixture.componentInstance; | |
| fixture.detectChanges(); | |
| }); | |
| it('should create', () => { | |
| expect(component).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/tab2/tab2.page.ts | |
| ````typescript | |
| import { Component } from '@angular/core'; | |
| import { IonHeader, IonToolbar, IonTitle, IonContent } from '@ionic/angular/standalone'; | |
| import { ExploreContainerComponent } from '../explore-container/explore-container.component'; | |
| @Component({ | |
| selector: 'app-tab2', | |
| templateUrl: 'tab2.page.html', | |
| styleUrls: ['tab2.page.scss'], | |
| imports: [IonHeader, IonToolbar, IonTitle, IonContent, ExploreContainerComponent] | |
| }) | |
| export class Tab2Page { | |
| constructor() {} | |
| } | |
| ```` | |
| ## File: mobile/src/app/tab3/tab3.page.html | |
| ````html | |
| <ion-header [translucent]="true"> | |
| <ion-toolbar> | |
| <ion-title> | |
| Tab 3 | |
| </ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <ion-content [fullscreen]="true"> | |
| <ion-header collapse="condense"> | |
| <ion-toolbar> | |
| <ion-title size="large">Tab 3</ion-title> | |
| </ion-toolbar> | |
| </ion-header> | |
| <app-explore-container name="Tab 3 page"></app-explore-container> | |
| </ion-content> | |
| ```` | |
| ## File: mobile/src/app/tab3/tab3.page.spec.ts | |
| ````typescript | |
| import { ComponentFixture, TestBed } from '@angular/core/testing'; | |
| import { Tab3Page } from './tab3.page'; | |
| describe('Tab3Page', () => { | |
| let component: Tab3Page; | |
| let fixture: ComponentFixture<Tab3Page>; | |
| beforeEach(async () => { | |
| fixture = TestBed.createComponent(Tab3Page); | |
| component = fixture.componentInstance; | |
| fixture.detectChanges(); | |
| }); | |
| it('should create', () => { | |
| expect(component).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/tab3/tab3.page.ts | |
| ````typescript | |
| import { Component } from '@angular/core'; | |
| import { IonHeader, IonToolbar, IonTitle, IonContent } from '@ionic/angular/standalone'; | |
| import { ExploreContainerComponent } from '../explore-container/explore-container.component'; | |
| @Component({ | |
| selector: 'app-tab3', | |
| templateUrl: 'tab3.page.html', | |
| styleUrls: ['tab3.page.scss'], | |
| imports: [IonHeader, IonToolbar, IonTitle, IonContent, ExploreContainerComponent], | |
| }) | |
| export class Tab3Page { | |
| constructor() {} | |
| } | |
| ```` | |
| ## File: mobile/src/app/tabs/tabs.page.html | |
| ````html | |
| <ion-tabs> | |
| <ion-tab-bar slot="bottom"> | |
| <ion-tab-button tab="tab1" href="/tabs/tab1"> | |
| <ion-icon aria-hidden="true" name="triangle"></ion-icon> | |
| <ion-label>Tab 1</ion-label> | |
| </ion-tab-button> | |
| <ion-tab-button tab="tab2" href="/tabs/tab2"> | |
| <ion-icon aria-hidden="true" name="ellipse"></ion-icon> | |
| <ion-label>Tab 2</ion-label> | |
| </ion-tab-button> | |
| <ion-tab-button tab="tab3" href="/tabs/tab3"> | |
| <ion-icon aria-hidden="true" name="square"></ion-icon> | |
| <ion-label>Tab 3</ion-label> | |
| </ion-tab-button> | |
| </ion-tab-bar> | |
| </ion-tabs> | |
| ```` | |
| ## File: mobile/src/app/tabs/tabs.page.scss | |
| ````scss | |
| ```` | |
| ## File: mobile/src/app/tabs/tabs.page.spec.ts | |
| ````typescript | |
| import { ComponentFixture, TestBed } from '@angular/core/testing'; | |
| import { provideRouter } from '@angular/router'; | |
| import { TabsPage } from './tabs.page'; | |
| describe('TabsPage', () => { | |
| let component: TabsPage; | |
| let fixture: ComponentFixture<TabsPage>; | |
| beforeEach(async () => { | |
| await TestBed.configureTestingModule({ | |
| imports: [TabsPage], | |
| providers: [provideRouter([])] | |
| }).compileComponents(); | |
| }); | |
| beforeEach(() => { | |
| fixture = TestBed.createComponent(TabsPage); | |
| component = fixture.componentInstance; | |
| fixture.detectChanges(); | |
| }); | |
| it('should create', () => { | |
| expect(component).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/tabs/tabs.page.ts | |
| ````typescript | |
| import { Component, EnvironmentInjector, inject } from '@angular/core'; | |
| import { IonTabs, IonTabBar, IonTabButton, IonIcon, IonLabel } from '@ionic/angular/standalone'; | |
| import { addIcons } from 'ionicons'; | |
| import { triangle, ellipse, square } from 'ionicons/icons'; | |
| @Component({ | |
| selector: 'app-tabs', | |
| templateUrl: 'tabs.page.html', | |
| styleUrls: ['tabs.page.scss'], | |
| imports: [IonTabs, IonTabBar, IonTabButton, IonIcon, IonLabel], | |
| }) | |
| export class TabsPage { | |
| public environmentInjector = inject(EnvironmentInjector); | |
| constructor() { | |
| addIcons({ triangle, ellipse, square }); | |
| } | |
| } | |
| ```` | |
| ## File: mobile/src/app/tabs/tabs.routes.ts | |
| ````typescript | |
| import { Routes } from '@angular/router'; | |
| import { TabsPage } from './tabs.page'; | |
| export const routes: Routes = [ | |
| { | |
| path: 'tabs', | |
| component: TabsPage, | |
| children: [ | |
| { | |
| path: 'tab1', | |
| loadComponent: () => | |
| import('../tab1/tab1.page').then((m) => m.Tab1Page), | |
| }, | |
| { | |
| path: 'tab2', | |
| loadComponent: () => | |
| import('../tab2/tab2.page').then((m) => m.Tab2Page), | |
| }, | |
| { | |
| path: 'tab3', | |
| loadComponent: () => | |
| import('../tab3/tab3.page').then((m) => m.Tab3Page), | |
| }, | |
| { | |
| path: '', | |
| redirectTo: '/tabs/tab1', | |
| pathMatch: 'full', | |
| }, | |
| ], | |
| }, | |
| { | |
| path: '', | |
| redirectTo: '/tabs/tab1', | |
| pathMatch: 'full', | |
| }, | |
| ]; | |
| ```` | |
| ## File: mobile/src/app/app.component.html | |
| ````html | |
| <ion-app> | |
| <ion-router-outlet></ion-router-outlet> | |
| </ion-app> | |
| ```` | |
| ## File: mobile/src/app/app.component.spec.ts | |
| ````typescript | |
| import { TestBed } from '@angular/core/testing'; | |
| import { provideRouter } from '@angular/router'; | |
| import { AppComponent } from './app.component'; | |
| describe('AppComponent', () => { | |
| it('should create the app', async () => { | |
| await TestBed.configureTestingModule({ | |
| imports: [AppComponent], | |
| providers: [provideRouter([])] | |
| }).compileComponents(); | |
| const fixture = TestBed.createComponent(AppComponent); | |
| const app = fixture.componentInstance; | |
| expect(app).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: mobile/src/app/app.component.ts | |
| ````typescript | |
| import { Component } from '@angular/core'; | |
| import { IonApp, IonRouterOutlet } from '@ionic/angular/standalone'; | |
| @Component({ | |
| selector: 'app-root', | |
| templateUrl: 'app.component.html', | |
| imports: [IonApp, IonRouterOutlet], | |
| }) | |
| export class AppComponent { | |
| constructor() {} | |
| } | |
| ```` | |
| ## File: mobile/src/app/app.routes.ts | |
| ````typescript | |
| import { Routes } from '@angular/router'; | |
| export const routes: Routes = [ | |
| { | |
| path: '', | |
| loadChildren: () => import('./tabs/tabs.routes').then((m) => m.routes), | |
| }, | |
| ]; | |
| ```` | |
| ## File: mobile/src/assets/shapes.svg | |
| ```` | |
| <svg width="350" height="140" xmlns="http://www.w3.org/2000/svg" style="background:#f6f7f9"><g fill="none" fill-rule="evenodd"><path fill="#F04141" style="mix-blend-mode:multiply" d="M61.905-34.23l96.194 54.51-66.982 54.512L22 34.887z"/><circle fill="#10DC60" style="mix-blend-mode:multiply" cx="155.5" cy="135.5" r="57.5"/><path fill="#3880FF" style="mix-blend-mode:multiply" d="M208.538 9.513l84.417 15.392L223.93 93.93z"/><path fill="#FFCE00" style="mix-blend-mode:multiply" d="M268.625 106.557l46.332-26.75 46.332 26.75v53.5l-46.332 26.75-46.332-26.75z"/><circle fill="#7044FF" style="mix-blend-mode:multiply" cx="299.5" cy="9.5" r="38.5"/><rect fill="#11D3EA" style="mix-blend-mode:multiply" transform="rotate(-60 148.47 37.886)" x="143.372" y="-7.056" width="10.196" height="89.884" rx="5.098"/><path d="M-25.389 74.253l84.86 8.107c5.498.525 9.53 5.407 9.004 10.905a10 10 0 0 1-.057.477l-12.36 85.671a10.002 10.002 0 0 1-11.634 8.42l-86.351-15.226c-5.44-.959-9.07-6.145-8.112-11.584l13.851-78.551a10 10 0 0 1 10.799-8.219z" fill="#7044FF" style="mix-blend-mode:multiply"/><circle fill="#0CD1E8" style="mix-blend-mode:multiply" cx="273.5" cy="106.5" r="20.5"/></g></svg> | |
| ```` | |
| ## File: mobile/src/environments/environment.prod.ts | |
| ````typescript | |
| export const environment = { | |
| production: true | |
| }; | |
| ```` | |
| ## File: mobile/src/environments/environment.ts | |
| ````typescript | |
| // This file can be replaced during build by using the `fileReplacements` array. | |
| // `ng build` replaces `environment.ts` with `environment.prod.ts`. | |
| // The list of file replacements can be found in `angular.json`. | |
| export const environment = { | |
| production: false | |
| }; | |
| /* | |
| * For easier debugging in development mode, you can import the following file | |
| * to ignore zone related error stack frames such as `zone.run`, `zoneDelegate.invokeTask`. | |
| * | |
| * This import should be commented out in production mode because it will have a negative impact | |
| * on performance if an error is thrown. | |
| */ | |
| // import 'zone.js/plugins/zone-error'; // Included with Angular CLI. | |
| ```` | |
| ## File: mobile/src/theme/variables.scss | |
| ````scss | |
| // For information on how to create your own theme, please see: | |
| // http://ionicframework.com/docs/theming/ | |
| ```` | |
| ## File: mobile/src/global.scss | |
| ````scss | |
| /* | |
| * App Global CSS | |
| * ---------------------------------------------------------------------------- | |
| * Put style rules here that you want to apply globally. These styles are for | |
| * the entire app and not just one component. Additionally, this file can be | |
| * used as an entry point to import other CSS/Sass files to be included in the | |
| * output CSS. | |
| * For more information on global stylesheets, visit the documentation: | |
| * https://ionicframework.com/docs/layout/global-stylesheets | |
| */ | |
| /* Core CSS required for Ionic components to work properly */ | |
| @import "@ionic/angular/css/core.css"; | |
| /* Basic CSS for apps built with Ionic */ | |
| @import "@ionic/angular/css/normalize.css"; | |
| @import "@ionic/angular/css/structure.css"; | |
| @import "@ionic/angular/css/typography.css"; | |
| @import "@ionic/angular/css/display.css"; | |
| /* Optional CSS utils that can be commented out */ | |
| @import "@ionic/angular/css/padding.css"; | |
| @import "@ionic/angular/css/float-elements.css"; | |
| @import "@ionic/angular/css/text-alignment.css"; | |
| @import "@ionic/angular/css/text-transformation.css"; | |
| @import "@ionic/angular/css/flex-utils.css"; | |
| /** | |
| * Ionic Dark Mode | |
| * ----------------------------------------------------- | |
| * For more info, please see: | |
| * https://ionicframework.com/docs/theming/dark-mode | |
| */ | |
| /* @import "@ionic/angular/css/palettes/dark.always.css"; */ | |
| /* @import "@ionic/angular/css/palettes/dark.class.css"; */ | |
| @import '@ionic/angular/css/palettes/dark.system.css'; | |
| ```` | |
| ## File: mobile/src/index.html | |
| ````html | |
| <!DOCTYPE html> | |
| <html lang="en"> | |
| <head> | |
| <meta charset="utf-8" /> | |
| <title>Ionic App</title> | |
| <base href="/" /> | |
| <meta name="color-scheme" content="light dark" /> | |
| <meta name="viewport" content="viewport-fit=cover, width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no" /> | |
| <meta name="format-detection" content="telephone=no" /> | |
| <meta name="msapplication-tap-highlight" content="no" /> | |
| <link rel="icon" type="image/png" href="assets/icon/favicon.png" /> | |
| <!-- add to homescreen for ios --> | |
| <meta name="mobile-web-app-capable" content="yes" /> | |
| <meta name="apple-mobile-web-app-status-bar-style" content="black" /> | |
| </head> | |
| <body> | |
| <app-root></app-root> | |
| </body> | |
| </html> | |
| ```` | |
| ## File: mobile/src/main.ts | |
| ````typescript | |
| import { bootstrapApplication } from '@angular/platform-browser'; | |
| import { RouteReuseStrategy, provideRouter, withPreloading, PreloadAllModules } from '@angular/router'; | |
| import { IonicRouteStrategy, provideIonicAngular } from '@ionic/angular/standalone'; | |
| import { routes } from './app/app.routes'; | |
| import { AppComponent } from './app/app.component'; | |
| bootstrapApplication(AppComponent, { | |
| providers: [ | |
| { provide: RouteReuseStrategy, useClass: IonicRouteStrategy }, | |
| provideIonicAngular(), | |
| provideRouter(routes, withPreloading(PreloadAllModules)), | |
| ], | |
| }); | |
| ```` | |
| ## File: mobile/src/polyfills.ts | |
| ````typescript | |
| /** | |
| * This file includes polyfills needed by Angular and is loaded before the app. | |
| * You can add your own extra polyfills to this file. | |
| * | |
| * This file is divided into 2 sections: | |
| * 1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers. | |
| * 2. Application imports. Files imported after ZoneJS that should be loaded before your main | |
| * file. | |
| * | |
| * The current setup is for so-called "evergreen" browsers; the last versions of browsers that | |
| * automatically update themselves. This includes recent versions of Safari, Chrome (including | |
| * Opera), Edge on the desktop, and iOS and Chrome on mobile. | |
| * | |
| * Learn more in https://angular.io/guide/browser-support | |
| */ | |
| /*************************************************************************************************** | |
| * BROWSER POLYFILLS | |
| */ | |
| /** | |
| * By default, zone.js will patch all possible macroTask and DomEvents | |
| * user can disable parts of macroTask/DomEvents patch by setting following flags | |
| * because those flags need to be set before `zone.js` being loaded, and webpack | |
| * will put import in the top of bundle, so user need to create a separate file | |
| * in this directory (for example: zone-flags.ts), and put the following flags | |
| * into that file, and then add the following code before importing zone.js. | |
| * import './zone-flags'; | |
| * | |
| * The flags allowed in zone-flags.ts are listed here. | |
| * | |
| * The following flags will work for all browsers. | |
| * | |
| * (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame | |
| * (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick | |
| * (window as any).__zone_symbol__UNPATCHED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames | |
| * | |
| * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js | |
| * with the following flag, it will bypass `zone.js` patch for IE/Edge | |
| * | |
| * (window as any).__Zone_enable_cross_context_check = true; | |
| * | |
| */ | |
| import './zone-flags'; | |
| /*************************************************************************************************** | |
| * Zone JS is required by default for Angular itself. | |
| */ | |
| import 'zone.js'; // Included with Angular CLI. | |
| /*************************************************************************************************** | |
| * APPLICATION IMPORTS | |
| */ | |
| ```` | |
| ## File: mobile/src/test.ts | |
| ````typescript | |
| // This file is required by karma.conf.js and loads recursively all the .spec and framework files | |
| import 'zone.js/testing'; | |
| import { getTestBed } from '@angular/core/testing'; | |
| import { | |
| BrowserDynamicTestingModule, | |
| platformBrowserDynamicTesting | |
| } from '@angular/platform-browser-dynamic/testing'; | |
| // First, initialize the Angular testing environment. | |
| getTestBed().initTestEnvironment( | |
| BrowserDynamicTestingModule, | |
| platformBrowserDynamicTesting(), | |
| ); | |
| ```` | |
| ## File: mobile/src/zone-flags.ts | |
| ````typescript | |
| /** | |
| * Prevents Angular change detection from | |
| * running with certain Web Component callbacks | |
| */ | |
| // eslint-disable-next-line no-underscore-dangle | |
| (window as any).__Zone_disable_customElements = true; | |
| ```` | |
| ## File: mobile/.browserslistrc | |
| ```` | |
| # This file is used by the build system to adjust CSS and JS output to support the specified browsers below. | |
| # For additional information regarding the format and rule options, please see: | |
| # https://github.com/browserslist/browserslist#queries | |
| # For the full list of supported browsers by the Angular framework, please see: | |
| # https://angular.dev/reference/versions#browser-support | |
| # You can see what browsers were selected by your queries by running: | |
| # npx browserslist | |
| Chrome >=107 | |
| Firefox >=106 | |
| Edge >=107 | |
| Safari >=16.1 | |
| iOS >=16.1 | |
| ```` | |
| ## File: mobile/.editorconfig | |
| ```` | |
| # Editor configuration, see https://editorconfig.org | |
| root = true | |
| [*] | |
| charset = utf-8 | |
| indent_style = space | |
| indent_size = 2 | |
| insert_final_newline = true | |
| trim_trailing_whitespace = true | |
| [*.ts] | |
| quote_type = single | |
| [*.md] | |
| max_line_length = off | |
| trim_trailing_whitespace = false | |
| ```` | |
| ## File: mobile/.eslintrc.json | |
| ````json | |
| { | |
| "root": true, | |
| "ignorePatterns": ["projects/**/*"], | |
| "overrides": [ | |
| { | |
| "files": ["*.ts"], | |
| "parserOptions": { | |
| "project": ["tsconfig.json"], | |
| "createDefaultProgram": true | |
| }, | |
| "extends": [ | |
| "plugin:@angular-eslint/recommended", | |
| "plugin:@angular-eslint/template/process-inline-templates" | |
| ], | |
| "rules": { | |
| "@angular-eslint/component-class-suffix": [ | |
| "error", | |
| { | |
| "suffixes": ["Page", "Component"] | |
| } | |
| ], | |
| "@angular-eslint/component-selector": [ | |
| "error", | |
| { | |
| "type": "element", | |
| "prefix": "app", | |
| "style": "kebab-case" | |
| } | |
| ], | |
| "@angular-eslint/directive-selector": [ | |
| "error", | |
| { | |
| "type": "attribute", | |
| "prefix": "app", | |
| "style": "camelCase" | |
| } | |
| ] | |
| } | |
| }, | |
| { | |
| "files": ["*.html"], | |
| "extends": ["plugin:@angular-eslint/template/recommended"], | |
| "rules": {} | |
| } | |
| ] | |
| } | |
| ```` | |
| ## File: mobile/.gitignore | |
| ```` | |
| # Specifies intentionally untracked files to ignore when using Git | |
| # http://git-scm.com/docs/gitignore | |
| *~ | |
| *.sw[mnpcod] | |
| .tmp | |
| *.tmp | |
| *.tmp.* | |
| UserInterfaceState.xcuserstate | |
| $RECYCLE.BIN/ | |
| *.log | |
| log.txt | |
| /.sourcemaps | |
| /.versions | |
| /coverage | |
| # Ionic | |
| /.ionic | |
| /www | |
| /platforms | |
| /plugins | |
| # Compiled output | |
| /dist | |
| /tmp | |
| /out-tsc | |
| /bazel-out | |
| # Node | |
| /node_modules | |
| npm-debug.log | |
| yarn-error.log | |
| # IDEs and editors | |
| .idea/ | |
| .project | |
| .classpath | |
| .c9/ | |
| *.launch | |
| .settings/ | |
| *.sublime-project | |
| *.sublime-workspace | |
| # Visual Studio Code | |
| .vscode/* | |
| !.vscode/settings.json | |
| !.vscode/tasks.json | |
| !.vscode/launch.json | |
| !.vscode/extensions.json | |
| .history/* | |
| # Miscellaneous | |
| /.angular | |
| /.angular/cache | |
| .sass-cache/ | |
| /.nx | |
| /.nx/cache | |
| /connect.lock | |
| /coverage | |
| /libpeerconnection.log | |
| testem.log | |
| /typings | |
| # System files | |
| .DS_Store | |
| Thumbs.db | |
| keystore.txt | |
| my-dashboard.jks | |
| artifacts | |
| ```` | |
| ## File: mobile/angular.json | |
| ````json | |
| { | |
| "$schema": "./node_modules/@angular/cli/lib/config/schema.json", | |
| "version": 1, | |
| "newProjectRoot": "projects", | |
| "projects": { | |
| "app": { | |
| "projectType": "application", | |
| "schematics": { | |
| "@ionic/angular-toolkit:page": { | |
| "styleext": "scss", | |
| "standalone": true | |
| } | |
| }, | |
| "root": "", | |
| "sourceRoot": "src", | |
| "prefix": "app", | |
| "architect": { | |
| "build": { | |
| "builder": "@angular-devkit/build-angular:application", | |
| "options": { | |
| "outputPath": { | |
| "base": "www", | |
| "browser": "" | |
| }, | |
| "index": "src/index.html", | |
| "polyfills": [ | |
| "src/polyfills.ts" | |
| ], | |
| "tsConfig": "tsconfig.app.json", | |
| "inlineStyleLanguage": "scss", | |
| "assets": [ | |
| { | |
| "glob": "**/*", | |
| "input": "src/assets", | |
| "output": "assets" | |
| } | |
| ], | |
| "styles": ["src/global.scss", "src/theme/variables.scss"], | |
| "scripts": [], | |
| "browser": "src/main.ts" | |
| }, | |
| "configurations": { | |
| "production": { | |
| "budgets": [ | |
| { | |
| "type": "initial", | |
| "maximumWarning": "2mb", | |
| "maximumError": "5mb" | |
| }, | |
| { | |
| "type": "anyComponentStyle", | |
| "maximumWarning": "2kb", | |
| "maximumError": "4kb" | |
| } | |
| ], | |
| "fileReplacements": [ | |
| { | |
| "replace": "src/environments/environment.ts", | |
| "with": "src/environments/environment.prod.ts" | |
| } | |
| ], | |
| "outputHashing": "all" | |
| }, | |
| "development": { | |
| "optimization": false, | |
| "extractLicenses": false, | |
| "sourceMap": true, | |
| "namedChunks": true | |
| }, | |
| "ci": { | |
| "progress": false | |
| } | |
| }, | |
| "defaultConfiguration": "production" | |
| }, | |
| "serve": { | |
| "builder": "@angular-devkit/build-angular:dev-server", | |
| "configurations": { | |
| "production": { | |
| "buildTarget": "app:build:production" | |
| }, | |
| "development": { | |
| "buildTarget": "app:build:development" | |
| }, | |
| "ci": { | |
| "progress": false | |
| } | |
| }, | |
| "defaultConfiguration": "development" | |
| }, | |
| "extract-i18n": { | |
| "builder": "@angular-devkit/build-angular:extract-i18n", | |
| "options": { | |
| "buildTarget": "app:build" | |
| } | |
| }, | |
| "test": { | |
| "builder": "@angular-devkit/build-angular:karma", | |
| "options": { | |
| "main": "src/test.ts", | |
| "polyfills": "src/polyfills.ts", | |
| "tsConfig": "tsconfig.spec.json", | |
| "karmaConfig": "karma.conf.js", | |
| "inlineStyleLanguage": "scss", | |
| "assets": [ | |
| { | |
| "glob": "**/*", | |
| "input": "src/assets", | |
| "output": "assets" | |
| } | |
| ], | |
| "styles": ["src/global.scss", "src/theme/variables.scss"], | |
| "scripts": [] | |
| }, | |
| "configurations": { | |
| "ci": { | |
| "progress": false, | |
| "watch": false | |
| } | |
| } | |
| }, | |
| "lint": { | |
| "builder": "@angular-eslint/builder:lint", | |
| "options": { | |
| "lintFilePatterns": ["src/**/*.ts", "src/**/*.html"] | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "cli": { | |
| "schematicCollections": [ | |
| "@ionic/angular-toolkit" | |
| ], | |
| "analytics": false | |
| }, | |
| "schematics": { | |
| "@ionic/angular-toolkit:component": { | |
| "styleext": "scss" | |
| }, | |
| "@ionic/angular-toolkit:page": { | |
| "styleext": "scss" | |
| }, | |
| "@angular-eslint/schematics:application": { | |
| "setParserOptionsProject": true | |
| }, | |
| "@angular-eslint/schematics:library": { | |
| "setParserOptionsProject": true | |
| } | |
| } | |
| } | |
| ```` | |
| ## File: mobile/capacitor.config.ts | |
| ````typescript | |
| import type { CapacitorConfig } from '@capacitor/cli'; | |
| const config: CapacitorConfig = { | |
| appId: 'ru.site15.MyDashboard', | |
| appName: 'MyDashboard', | |
| webDir: 'www', | |
| "android": { | |
| "buildOptions": { | |
| "releaseType": "APK", | |
| "keystorePath": "../my-dashboard.jks", | |
| "keystorePassword": "12345678", | |
| "keystoreAlias": "my-dashboard", | |
| "keystoreAliasPassword": "12345678" | |
| } | |
| } | |
| }; | |
| export default config; | |
| ```` | |
| ## File: mobile/ionic.config.json | |
| ````json | |
| { | |
| "name": "MyDashboard", | |
| "integrations": { | |
| "capacitor": {} | |
| }, | |
| "type": "angular-standalone" | |
| } | |
| ```` | |
| ## File: mobile/karma.conf.js | |
| ````javascript | |
| // Karma configuration file, see link for more information | |
| // https://karma-runner.github.io/1.0/config/configuration-file.html | |
| module.exports = function (config) { | |
| config.set({ | |
| basePath: '', | |
| frameworks: ['jasmine', '@angular-devkit/build-angular'], | |
| plugins: [ | |
| require('karma-jasmine'), | |
| require('karma-chrome-launcher'), | |
| require('karma-jasmine-html-reporter'), | |
| require('karma-coverage'), | |
| require('@angular-devkit/build-angular/plugins/karma') | |
| ], | |
| client: { | |
| jasmine: { | |
| // you can add configuration options for Jasmine here | |
| // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html | |
| // for example, you can disable the random execution with `random: false` | |
| // or set a specific seed with `seed: 4321` | |
| }, | |
| clearContext: false // leave Jasmine Spec Runner output visible in browser | |
| }, | |
| jasmineHtmlReporter: { | |
| suppressAll: true // removes the duplicated traces | |
| }, | |
| coverageReporter: { | |
| dir: require('path').join(__dirname, './coverage/app'), | |
| subdir: '.', | |
| reporters: [ | |
| { type: 'html' }, | |
| { type: 'text-summary' } | |
| ] | |
| }, | |
| reporters: ['progress', 'kjhtml'], | |
| port: 9876, | |
| colors: true, | |
| logLevel: config.LOG_INFO, | |
| autoWatch: true, | |
| browsers: ['Chrome'], | |
| singleRun: false, | |
| restartOnFileChange: true | |
| }); | |
| }; | |
| ```` | |
| ## File: mobile/package.json | |
| ````json | |
| { | |
| "name": "MyDashboard", | |
| "version": "0.0.13", | |
| "description": "An Ionic-Angular mobile application with Capacitor integration for Android deployment. Features a tabbed interface with explore container and dynamic routing.", | |
| "author": "Ilshat Khamitov <[email protected]>", | |
| "scripts": { | |
| "ng": "ng", | |
| "start": "ng serve", | |
| "build": "ng build", | |
| "watch": "ng build --watch --configuration development", | |
| "test": "ng test", | |
| "lint": "ng lint" | |
| }, | |
| "private": true, | |
| "dependencies": { | |
| "@angular/animations": "^20.0.0", | |
| "@angular/common": "^20.0.0", | |
| "@angular/compiler": "^20.0.0", | |
| "@angular/core": "^20.0.0", | |
| "@angular/forms": "^20.0.0", | |
| "@angular/platform-browser": "^20.0.0", | |
| "@angular/platform-browser-dynamic": "^20.0.0", | |
| "@angular/router": "^20.0.0", | |
| "@capacitor/android": "7.4.4", | |
| "@capacitor/app": "7.1.0", | |
| "@capacitor/core": "7.4.4", | |
| "@capacitor/haptics": "7.0.2", | |
| "@capacitor/keyboard": "7.0.3", | |
| "@capacitor/status-bar": "7.0.3", | |
| "@ionic/angular": "^8.0.0", | |
| "ionicons": "^7.0.0", | |
| "rxjs": "~7.8.0", | |
| "tslib": "^2.3.0", | |
| "zone.js": "~0.15.0" | |
| }, | |
| "devDependencies": { | |
| "@angular-devkit/build-angular": "^20.0.0", | |
| "@angular-eslint/builder": "^20.0.0", | |
| "@angular-eslint/eslint-plugin": "^20.0.0", | |
| "@angular-eslint/eslint-plugin-template": "^20.0.0", | |
| "@angular-eslint/schematics": "^20.0.0", | |
| "@angular-eslint/template-parser": "^20.0.0", | |
| "@angular/cli": "^20.0.0", | |
| "@angular/compiler-cli": "^20.0.0", | |
| "@angular/language-service": "^20.0.0", | |
| "@capacitor/cli": "7.4.4", | |
| "@ionic/angular-toolkit": "^12.0.0", | |
| "@ionic/cli": "^7.2.1", | |
| "@types/jasmine": "~5.1.0", | |
| "@typescript-eslint/eslint-plugin": "^8.18.0", | |
| "@typescript-eslint/parser": "^8.18.0", | |
| "eslint": "^9.16.0", | |
| "eslint-plugin-import": "^2.29.1", | |
| "eslint-plugin-jsdoc": "^48.2.1", | |
| "eslint-plugin-prefer-arrow": "1.2.2", | |
| "jasmine-core": "~5.1.0", | |
| "jasmine-spec-reporter": "~5.0.0", | |
| "karma": "~6.4.0", | |
| "karma-chrome-launcher": "~3.2.0", | |
| "karma-coverage": "~2.2.0", | |
| "karma-jasmine": "~5.1.0", | |
| "karma-jasmine-html-reporter": "~2.1.0", | |
| "typescript": "~5.8.0" | |
| } | |
| } | |
| ```` | |
| ## File: mobile/README_RU.md | |
| ````markdown | |
| # Сборка мобильного приложения через Docker | |
| ## Демо | |
| Веб-приложение развернуто и доступно по адресу: https://site15-my-dashboard.vercel.app | |
| ## Docker контейнер | |
| Документация по сборке Docker контейнера была перенесена в каталог [ionic_capacitor](../ionic_capacitor): | |
| - [Документация по сборке Docker контейнера (на английском)](../ionic_capacitor/README.md) | |
| - [Документация по сборке Docker контейнера (на русском)](../ionic_capacitor/README_RU.md) | |
| ## Сообщество | |
| Присоединяйтесь к нашему Telegram-чату разработчиков для обсуждений, обновлений и поддержки: | |
| - [Telegram-чат разработчиков](https://t.me/site15_community) | |
| ## Уведомления о релизах | |
| Информация о релизах и обновлениях автоматически публикуется в нашем Telegram-чате сообщества: | |
| - [Уведомления о релизах в Telegram](https://t.me/site15_community/3) | |
| ## Запуск сборки с монтированием тома | |
| Чтобы собрать APK для Android с помощью Docker с монтированием тома: | |
| ```bash | |
| docker run --rm -v "$(pwd)":/app endykaufman/ionic-capacitor:latest | |
| ``` | |
| ## Рабочий процесс GitHub Actions | |
| Рабочий процесс GitHub Actions автоматически: | |
| 1. Собирает образ Docker | |
| 2. Запускает процесс сборки Android | |
| 3. Загружает файлы APK как артефакты | |
| Файлы APK будут доступны в артефактах GitHub Actions по адресу: | |
| `/app/android/app/build/outputs/apk/release/` | |
| Чтобы использовать параметры хранилища ключей через секреты GitHub, необходимо установить следующие секреты в вашем репозитории: | |
| - `KEYSTORE` - закодированный в base64 файл хранилища ключей | |
| - `KEYSTORE_PASSWORD` - пароль для хранилища ключей | |
| - `KEYSTORE_ALIAS` - псевдоним для хранилища ключей | |
| - `KEYSTORE_ALIAS_PASSWORD` - пароль для псевдонима хранилища ключей | |
| Чтобы сгенерировать закодированный в base64 файл хранилища ключей: | |
| ```bash | |
| base64 my-dashboard.jks > keystore.txt | |
| ``` | |
| Затем скопируйте содержимое файла keystore.txt в секрет `KEYSTORE` в настройках репозитория GitHub. | |
| ## Процесс ручной сборки | |
| 1. Сгенерируйте хранилище ключей (если у вас его нет): | |
| ```bash | |
| keytool -genkey -v -keystore my-dashboard.jks -keyalg RSA -keysize 2048 -storepass 12345678 -keypass 12345678 -validity 10000 -alias my-dashboard -dname "CN=Ilshat Khamitov, OU=My Dashboard, O=Site15, L=Ufa, ST=Unknown, C=ru" | |
| ``` | |
| 2. Запустите контейнер Docker: | |
| ```bash | |
| docker run --rm -v "$(pwd)":/app endykaufman/ionic-capacitor:latest | |
| ``` | |
| 3. APK будет сгенерирован по адресу: | |
| `android/app/build/outputs/apk/release/app-release.apk` | |
| ## Разработка | |
| - Запустите `ionic serve` чтобы увидеть ваше приложение в браузере | |
| - Запустите `ionic capacitor add` чтобы добавить нативный проект iOS или Android с помощью Capacitor | |
| - Сгенерируйте иконку и заставку вашего приложения с помощью `cordova-res --skip-config --copy` | |
| - Изучите документацию Ionic для компонентов, руководств и другого: https://ion.link/docs | |
| - Создаете корпоративное приложение? У Ionic есть поддержка и функции для предприятий: https://ion.link/enterprise-edition | |
| ```` | |
| ## File: mobile/README.md | |
| ````markdown | |
| # Mobile App Docker Build | |
| ## Live Demo | |
| The web application is deployed and available at: https://site15-my-dashboard.vercel.app | |
| ## Docker Container | |
| Docker container build documentation has been moved to the [ionic_capacitor](../ionic_capacitor) directory: | |
| - [Docker Container Build Documentation (English)](../ionic_capacitor/README.md) | |
| - [Docker Container Build Documentation (Russian)](../ionic_capacitor/README_RU.md) | |
| ## Community | |
| Join our Telegram developer community for discussions, updates, and support: | |
| - [Telegram Developer Chat](https://t.me/site15_community) | |
| ## Release Notifications | |
| Release information and updates are automatically posted to our Telegram community chat: | |
| - [Telegram Release Notifications](https://t.me/site15_community/3) | |
| ## Running the Build with Volume Mounting | |
| To build the Android APK using Docker with volume mounting: | |
| ```bash | |
| docker run --rm -v "$(pwd)":/app endykaufman/ionic-capacitor:latest | |
| ``` | |
| ## GitHub Actions Workflow | |
| The GitHub Actions workflow automatically: | |
| 1. Builds the Docker image | |
| 2. Runs the Android build process | |
| 3. Uploads the APK files as artifacts | |
| The APK files will be available in the GitHub Actions artifacts at: | |
| `/app/android/app/build/outputs/apk/release/` | |
| To use GitHub secrets for keystore parameters, you need to set the following secrets in your repository: | |
| - `KEYSTORE` - Base64 encoded keystore file | |
| - `KEYSTORE_PASSWORD` - Password for the keystore | |
| - `KEYSTORE_ALIAS` - Alias for the keystore | |
| - `KEYSTORE_ALIAS_PASSWORD` - Password for the keystore alias | |
| To generate the base64 encoded keystore: | |
| ```bash | |
| base64 my-dashboard.jks > keystore.txt | |
| ``` | |
| Then copy the contents of keystore.txt to the `KEYSTORE` secret in your GitHub repository settings. | |
| ## Manual Build Process | |
| 1. Generate a keystore (if you don't have one): | |
| ```bash | |
| keytool -genkey -v -keystore my-dashboard.jks -keyalg RSA -keysize 2048 -storepass 12345678 -keypass 12345678 -validity 10000 -alias my-dashboard -dname "CN=Ilshat Khamitov, OU=My Dashboard, O=Site15, L=Ufa, ST=Unknown, C=ru" | |
| ``` | |
| 2. Run the Docker container: | |
| ```bash | |
| docker run --rm -v "$(pwd)":/app endykaufman/ionic-capacitor:latest | |
| ``` | |
| 3. The APK will be generated at: | |
| `android/app/build/outputs/apk/release/app-release.apk` | |
| ## Development | |
| - Run `ionic serve` to see your app in the browser | |
| - Run `ionic capacitor add` to add a native iOS or Android project using Capacitor | |
| - Generate your app icon and splash screens using `cordova-res --skip-config --copy` | |
| - Explore the Ionic docs for components, tutorials, and more: https://ion.link/docs | |
| - Building an enterprise app? Ionic has Enterprise Support and Features: https://ion.link/enterprise-edition | |
| ```` | |
| ## File: mobile/tsconfig.app.json | |
| ````json | |
| /* To learn more about this file see: https://angular.io/config/tsconfig. */ | |
| { | |
| "extends": "./tsconfig.json", | |
| "compilerOptions": { | |
| "outDir": "./out-tsc/app", | |
| "types": [] | |
| }, | |
| "files": [ | |
| "src/main.ts", | |
| "src/polyfills.ts" | |
| ], | |
| "include": [ | |
| "src/**/*.d.ts" | |
| ] | |
| } | |
| ```` | |
| ## File: mobile/tsconfig.json | |
| ````json | |
| /* To learn more about this file see: https://angular.io/config/tsconfig. */ | |
| { | |
| "compileOnSave": false, | |
| "compilerOptions": { | |
| "baseUrl": "./", | |
| "outDir": "./dist/out-tsc", | |
| "forceConsistentCasingInFileNames": true, | |
| "esModuleInterop": true, | |
| "strict": true, | |
| "noImplicitOverride": true, | |
| "noPropertyAccessFromIndexSignature": true, | |
| "noImplicitReturns": true, | |
| "noFallthroughCasesInSwitch": true, | |
| "sourceMap": true, | |
| "declaration": false, | |
| "experimentalDecorators": true, | |
| "moduleResolution": "node", | |
| "importHelpers": true, | |
| "target": "es2022", | |
| "module": "es2020", | |
| "lib": ["es2018", "dom"], | |
| "useDefineForClassFields": false | |
| }, | |
| "angularCompilerOptions": { | |
| "enableI18nLegacyMessageIdFormat": false, | |
| "strictInjectionParameters": true, | |
| "strictInputAccessModifiers": true, | |
| "strictTemplates": true | |
| } | |
| } | |
| ```` | |
| ## File: mobile/tsconfig.spec.json | |
| ````json | |
| /* To learn more about this file see: https://angular.io/config/tsconfig. */ | |
| { | |
| "extends": "./tsconfig.json", | |
| "compilerOptions": { | |
| "outDir": "./out-tsc/spec", | |
| "types": [ | |
| "jasmine" | |
| ] | |
| }, | |
| "files": [ | |
| "src/test.ts", | |
| "src/polyfills.ts" | |
| ], | |
| "include": [ | |
| "src/**/*.spec.ts", | |
| "src/**/*.d.ts" | |
| ] | |
| } | |
| ```` | |
| ## File: mobile/update-capacitor-config.js | |
| ````javascript | |
| const fs = require('fs'); | |
| // Get environment variables or use defaults | |
| const keystorePassword = process.env.KEYSTORE_PASSWORD || '12345678'; | |
| const keystoreAlias = process.env.KEYSTORE_ALIAS || 'my-dashboard'; | |
| const keystoreAliasPassword = process.env.KEYSTORE_ALIAS_PASSWORD || '12345678'; | |
| // Read the template file | |
| const configTemplate = ` | |
| import type { CapacitorConfig } from '@capacitor/cli'; | |
| const config: CapacitorConfig = { | |
| appId: 'ru.site15.MyDashboard', | |
| appName: 'MyDashboard', | |
| webDir: 'www', | |
| "android": { | |
| "buildOptions": { | |
| "releaseType": "APK", | |
| "keystorePath": "../my-dashboard.jks", | |
| "keystorePassword": "${keystorePassword}", | |
| "keystoreAlias": "${keystoreAlias}", | |
| "keystoreAliasPassword": "${keystoreAliasPassword}" | |
| } | |
| } | |
| }; | |
| export default config; | |
| `; | |
| // Write the updated config file | |
| fs.writeFileSync('capacitor.config.ts', configTemplate.trim()); | |
| console.log('capacitor.config.ts has been updated with environment variables'); | |
| ```` | |
| ## File: web/.vscode/extensions.json | |
| ````json | |
| { | |
| // For more information, visit: https://go.microsoft.com/fwlink/?linkid=827846 | |
| "recommendations": ["angular.ng-template", "analogjs.vscode-analog", "vitest.explorer"] | |
| } | |
| ```` | |
| ## File: web/.vscode/launch.json | |
| ````json | |
| { | |
| // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 | |
| "version": "0.2.0", | |
| "configurations": [ | |
| { | |
| "name": "ng serve", | |
| "type": "chrome", | |
| "request": "launch", | |
| "preLaunchTask": "npm: start", | |
| "url": "http://localhost:5173/" | |
| }, | |
| { | |
| "name": "ng test", | |
| "type": "chrome", | |
| "request": "launch", | |
| "preLaunchTask": "npm: test" | |
| } | |
| ] | |
| } | |
| ```` | |
| ## File: web/.vscode/tasks.json | |
| ````json | |
| { | |
| // For more information, visit: https://go.microsoft.com/fwlink/?LinkId=733558 | |
| "version": "2.0.0", | |
| "tasks": [ | |
| { | |
| "type": "npm", | |
| "script": "start", | |
| "isBackground": true, | |
| "problemMatcher": { | |
| "owner": "typescript", | |
| "pattern": "$tsc", | |
| "background": { | |
| "activeOnStart": true, | |
| "beginsPattern": { | |
| "regexp": "(.*?)" | |
| }, | |
| "endsPattern": { | |
| "regexp": "bundle generation complete" | |
| } | |
| } | |
| } | |
| }, | |
| { | |
| "type": "npm", | |
| "script": "test", | |
| "isBackground": true, | |
| "problemMatcher": { | |
| "owner": "typescript", | |
| "pattern": "$tsc", | |
| "background": { | |
| "activeOnStart": true, | |
| "beginsPattern": { | |
| "regexp": "(.*?)" | |
| }, | |
| "endsPattern": { | |
| "regexp": "bundle generation complete" | |
| } | |
| } | |
| } | |
| } | |
| ] | |
| } | |
| ```` | |
| ## File: web/prisma/migrations/20251030031037_add_users/migration.sql | |
| ````sql | |
| -- CreateTable | |
| CREATE TABLE "User" ( | |
| "id" TEXT NOT NULL, | |
| "externalId" TEXT, | |
| "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| CONSTRAINT "User_pkey" PRIMARY KEY ("id") | |
| ); | |
| ```` | |
| ## File: web/prisma/migrations/20251030194718_add_telegram_user_data_to_user/migration.sql | |
| ````sql | |
| -- AlterTable | |
| ALTER TABLE "User" ADD COLUMN "telegramUserData" JSONB; | |
| ```` | |
| ## File: web/prisma/migrations/20251031054243_update_pk/migration.sql | |
| ````sql | |
| /* | |
| Warnings: | |
| - The primary key for the `User` table will be changed. If it partially fails, the table could be left without primary key constraint. | |
| - Changed the type of `id` on the `User` table. No cast exists, the column would be dropped and recreated, which cannot be done if there is data, since the column is required. | |
| */ | |
| -- AlterTable | |
| ALTER TABLE "User" DROP CONSTRAINT "User_pkey", | |
| DROP COLUMN "id", | |
| ADD COLUMN "id" UUID NOT NULL, | |
| ADD CONSTRAINT "User_pkey" PRIMARY KEY ("id"); | |
| -- CreateTable | |
| CREATE TABLE "Session" ( | |
| "id" UUID NOT NULL, | |
| "userId" UUID NOT NULL, | |
| "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "deletedAt" TIMESTAMP(3), | |
| CONSTRAINT "Session_pkey" PRIMARY KEY ("id") | |
| ); | |
| -- CreateIndex | |
| CREATE INDEX "IDX_SESSION__USER_ID" ON "Session"("userId"); | |
| ```` | |
| ## File: web/prisma/migrations/20251031054333_add_session/migration.sql | |
| ````sql | |
| -- AddForeignKey | |
| ALTER TABLE "Session" ADD CONSTRAINT "FK_SESSION__USER_ID" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE NO ACTION ON UPDATE NO ACTION; | |
| ```` | |
| ## File: web/prisma/migrations/20251031054509_change_pk_name/migration.sql | |
| ````sql | |
| -- AlterTable | |
| ALTER TABLE "Session" RENAME CONSTRAINT "Session_pkey" TO "PK_SESSION"; | |
| -- AlterTable | |
| ALTER TABLE "User" RENAME CONSTRAINT "User_pkey" TO "PK_USER"; | |
| ```` | |
| ## File: web/prisma/migrations/20251031054615_change_external_user_id_to_telegram_user_id_string/migration.sql | |
| ````sql | |
| /* | |
| Warnings: | |
| - You are about to drop the column `externalId` on the `User` table. All the data in the column will be lost. | |
| */ | |
| -- AlterTable | |
| ALTER TABLE "User" DROP COLUMN "externalId", | |
| ADD COLUMN "telegramUserId" TEXT; | |
| ```` | |
| ## File: web/prisma/migrations/20251031071721_add_uniq_index_to_user/migration.sql | |
| ````sql | |
| /* | |
| Warnings: | |
| - A unique constraint covering the columns `[telegramUserId]` on the table `User` will be added. If there are existing duplicate values, this will fail. | |
| */ | |
| -- CreateIndex | |
| CREATE UNIQUE INDEX "UQ_USER" ON "User"("telegramUserId"); | |
| ```` | |
| ## File: web/prisma/migrations/20251110085211_append_all_need_tables_for_dashboards/migration.sql | |
| ````sql | |
| -- CreateTable | |
| CREATE TABLE "Dashboard" ( | |
| "id" UUID NOT NULL, | |
| "name" TEXT NOT NULL, | |
| "deviceId" TEXT, | |
| "userId" UUID NOT NULL, | |
| "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "deletedAt" TIMESTAMP(3), | |
| CONSTRAINT "PK_DASHBOARD" PRIMARY KEY ("id") | |
| ); | |
| -- CreateTable | |
| CREATE TABLE "Widget" ( | |
| "id" UUID NOT NULL, | |
| "options" JSONB, | |
| "columnIndex" INTEGER, | |
| "rowIndex" INTEGER, | |
| "columnCount" INTEGER, | |
| "rowCount" INTEGER, | |
| "light" BOOLEAN, | |
| "backgroundColor" TEXT, | |
| "primaryColor" TEXT, | |
| "positiveColor" TEXT, | |
| "negativeColor" TEXT, | |
| "dashboardId" UUID NOT NULL, | |
| "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "deletedAt" TIMESTAMP(3), | |
| CONSTRAINT "PK_WIDGET" PRIMARY KEY ("id") | |
| ); | |
| -- CreateIndex | |
| CREATE INDEX "IDX_DASHBOARD__USER_ID" ON "Dashboard"("userId"); | |
| -- CreateIndex | |
| CREATE UNIQUE INDEX "UQ_DASHBOARD__USER_ID_NAME" ON "Dashboard"("userId", "name"); | |
| -- CreateIndex | |
| CREATE UNIQUE INDEX "UQ_DASHBOARD__DEVICE_ID" ON "Dashboard"("deviceId"); | |
| -- CreateIndex | |
| CREATE INDEX "IDX_WIDGET__DASHBOARD_ID" ON "Widget"("dashboardId"); | |
| -- AddForeignKey | |
| ALTER TABLE "Dashboard" ADD CONSTRAINT "FK_DASHBOARD__USER_ID" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE NO ACTION ON UPDATE NO ACTION; | |
| -- AddForeignKey | |
| ALTER TABLE "Widget" ADD CONSTRAINT "FK_WIDGET__DASHBOARD_ID" FOREIGN KEY ("dashboardId") REFERENCES "Dashboard"("id") ON DELETE NO ACTION ON UPDATE NO ACTION; | |
| ```` | |
| ## File: web/prisma/migrations/20251110085731_add_widget_log_table/migration.sql | |
| ````sql | |
| -- AlterTable | |
| ALTER TABLE "Widget" ADD COLUMN "state" JSONB; | |
| -- CreateTable | |
| CREATE TABLE "WidgetLog" ( | |
| "id" UUID NOT NULL, | |
| "oldOptions" JSONB, | |
| "newOptions" JSONB, | |
| "oldState" JSONB, | |
| "newState" JSONB, | |
| "widgetId" UUID NOT NULL, | |
| "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, | |
| "deletedAt" TIMESTAMP(3), | |
| CONSTRAINT "PK_WIDGET_LOG" PRIMARY KEY ("id") | |
| ); | |
| -- CreateIndex | |
| CREATE INDEX "IDX_WIDGET_LOG__WIDGET_ID" ON "WidgetLog"("widgetId"); | |
| -- AddForeignKey | |
| ALTER TABLE "WidgetLog" ADD CONSTRAINT "FK_WIDGET_LOG__WIDGET_ID" FOREIGN KEY ("widgetId") REFERENCES "Widget"("id") ON DELETE NO ACTION ON UPDATE NO ACTION; | |
| ```` | |
| ## File: web/prisma/migrations/20251110091115_append_anonymous_id_to_user/migration.sql | |
| ````sql | |
| -- AlterTable | |
| ALTER TABLE "User" ADD COLUMN "anonymousId" TEXT; | |
| ```` | |
| ## File: web/prisma/migrations/20251110092600_append_is_black_theme_to_all_tables/migration.sql | |
| ````sql | |
| /* | |
| Warnings: | |
| - You are about to drop the column `light` on the `Widget` table. All the data in the column will be lost. | |
| */ | |
| -- AlterTable | |
| ALTER TABLE "Dashboard" ADD COLUMN "isBlackTheme" BOOLEAN; | |
| -- AlterTable | |
| ALTER TABLE "User" ADD COLUMN "isBlackTheme" BOOLEAN, | |
| ADD COLUMN "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP; | |
| -- AlterTable | |
| ALTER TABLE "Widget" DROP COLUMN "light", | |
| ADD COLUMN "isBlackTheme" BOOLEAN; | |
| ```` | |
| ## File: web/prisma/migrations/migration_lock.toml | |
| ````toml | |
| # Please do not edit this file manually | |
| # It should be added in your version-control system (e.g., Git) | |
| provider = "postgresql" | |
| ```` | |
| ## File: web/prisma/schema.prisma | |
| ```` | |
| // This is your Prisma schema file, | |
| // learn more about it in the docs: https://pris.ly/d/prisma-schema | |
| // Looking for ways to speed up your queries, or scale easily with your serverless or edge functions? | |
| // Try Prisma Accelerate: https://pris.ly/cli/accelerate-init | |
| generator client1 { | |
| provider = "prisma-client" | |
| output = "../src/app/generated/prisma" | |
| engineType = "client" | |
| } | |
| generator client2 { | |
| provider = "prisma-client" | |
| output = "../src/server/generated/prisma" | |
| engineType = "client" | |
| } | |
| datasource db { | |
| provider = "postgresql" | |
| url = env("MY_DASHBOARD_DATABASE_POSTGRES_URL") | |
| } | |
| model User { | |
| id String @id(map: "PK_USER") @default(uuid()) @db.Uuid | |
| anonymousId String? | |
| telegramUserId String? | |
| telegramUserData Json? | |
| isBlackTheme Boolean? | |
| createdAt DateTime @default(now()) | |
| updatedAt DateTime @default(now()) | |
| Session Session[] | |
| Dashboard Dashboard[] | |
| @@unique([telegramUserId], map: "UQ_USER") | |
| } | |
| model Session { | |
| id String @id(map: "PK_SESSION") @default(uuid()) @db.Uuid | |
| userId String @db.Uuid | |
| User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: "FK_SESSION__USER_ID") | |
| createdAt DateTime @default(now()) | |
| deletedAt DateTime? | |
| @@index([userId], map: "IDX_SESSION__USER_ID") | |
| } | |
| model Dashboard { | |
| id String @id(map: "PK_DASHBOARD") @default(uuid()) @db.Uuid | |
| name String | |
| deviceId String? | |
| userId String @db.Uuid | |
| isBlackTheme Boolean? | |
| User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: "FK_DASHBOARD__USER_ID") | |
| Widget Widget[] | |
| createdAt DateTime @default(now()) | |
| updatedAt DateTime @default(now()) | |
| deletedAt DateTime? | |
| @@unique([userId, name], map: "UQ_DASHBOARD__USER_ID_NAME") | |
| @@unique([deviceId], map: "UQ_DASHBOARD__DEVICE_ID") | |
| @@index([userId], map: "IDX_DASHBOARD__USER_ID") | |
| } | |
| model Widget { | |
| id String @id(map: "PK_WIDGET") @default(uuid()) @db.Uuid | |
| options Json? | |
| state Json? | |
| columnIndex Int? | |
| rowIndex Int? | |
| columnCount Int? | |
| rowCount Int? | |
| isBlackTheme Boolean? | |
| backgroundColor String? | |
| primaryColor String? | |
| positiveColor String? | |
| negativeColor String? | |
| // contrastMultiplier Float | |
| // textSaturationMultiplier Float | |
| dashboardId String @db.Uuid | |
| Dashboard Dashboard @relation(fields: [dashboardId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: "FK_WIDGET__DASHBOARD_ID") | |
| WidgetLog WidgetLog[] | |
| createdAt DateTime @default(now()) | |
| updatedAt DateTime @default(now()) | |
| deletedAt DateTime? | |
| @@index([dashboardId], map: "IDX_WIDGET__DASHBOARD_ID") | |
| } | |
| model WidgetLog { | |
| id String @id(map: "PK_WIDGET_LOG") @default(uuid()) @db.Uuid | |
| oldOptions Json? | |
| newOptions Json? | |
| oldState Json? | |
| newState Json? | |
| widgetId String @db.Uuid | |
| Widget Widget @relation(fields: [widgetId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: "FK_WIDGET_LOG__WIDGET_ID") | |
| createdAt DateTime @default(now()) | |
| updatedAt DateTime @default(now()) | |
| deletedAt DateTime? | |
| @@index([widgetId], map: "IDX_WIDGET_LOG__WIDGET_ID") | |
| } | |
| ```` | |
| ## File: web/public/analog.svg | |
| ```` | |
| <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="564" zoomAndPan="magnify" viewBox="0 0 422.88 343.499995" height="458" preserveAspectRatio="xMidYMid meet" version="1.0"><defs><clipPath id="id1"><path d="M 127.296875 75.375 L 347.570312 75.375 L 347.570312 267.527344 L 127.296875 267.527344 Z M 127.296875 75.375 " clip-rule="nonzero"/></clipPath><clipPath id="id2"><path d="M 75.871094 104 L 263.335938 104 L 263.335938 268.03125 L 75.871094 268.03125 Z M 75.871094 104 " clip-rule="nonzero"/></clipPath><clipPath id="id3"><path d="M 105 169.023438 L 315 169.023438 L 315 256.898438 L 105 256.898438 Z M 105 169.023438 " clip-rule="nonzero"/></clipPath></defs><g clip-path="url(#id1)"><path fill="#c30f2e" d="M 237.433594 75.378906 L 347.570312 267.527344 L 127.296875 267.527344 L 237.433594 75.378906 " fill-opacity="1" fill-rule="nonzero"/></g><g clip-path="url(#id2)"><path fill="#dd0330" d="M 169.601562 104 L 263.332031 268.03125 L 75.871094 268.03125 L 169.601562 104 " fill-opacity="1" fill-rule="nonzero"/></g><path fill="#ffffff" d="M 328.894531 218.96875 L 95.152344 218.96875 L 95.152344 216.402344 L 328.894531 216.402344 L 328.894531 218.96875 " fill-opacity="1" fill-rule="nonzero"/><g clip-path="url(#id3)"><path fill="#ffffff" d="M 292.785156 256.511719 C 291.871094 256.511719 291.011719 256.132812 290.292969 255.414062 C 286 251.101562 285.8125 233.566406 286.019531 207.304688 C 286.136719 192.953125 286.292969 173.296875 284.003906 171.746094 C 281.769531 172.671875 281.546875 188.910156 281.402344 199.660156 C 281.230469 212.167969 281.054688 225.109375 279.023438 231.699219 C 278.417969 233.652344 277.636719 235.441406 276.066406 235.296875 C 273.851562 235.101562 273.136719 231.605469 271.484375 217.808594 C 270.796875 212.078125 270.085938 206.15625 269.253906 203.863281 C 269.144531 203.574219 269.050781 203.34375 268.96875 203.164062 C 268.082031 205.167969 267.058594 210.675781 266.347656 214.5 C 265.363281 219.78125 264.433594 224.769531 263.269531 226.945312 C 262.371094 228.617188 260.945312 230.796875 258.953125 230.375 C 256.238281 229.804688 255.425781 224.332031 255.183594 221.121094 C 255.183594 194.105469 251.648438 190.960938 250.941406 190.605469 L 250.828125 190.691406 L 250.65625 190.652344 C 248.132812 191.753906 247.996094 200.515625 247.867188 208.988281 C 247.765625 215.203125 247.65625 222.246094 246.75 228.835938 C 245.574219 237.378906 244.152344 239.027344 242.382812 238.925781 C 238.308594 238.648438 238.191406 224.617188 238.191406 223.019531 C 238.191406 222.519531 238.203125 221.929688 238.21875 221.277344 C 238.296875 218.011719 238.4375 211.9375 236.429688 210.023438 C 236.164062 209.769531 235.789062 209.476562 235.496094 209.558594 C 234.066406 209.917969 232.582031 214.5625 232.089844 216.089844 C 231.933594 216.574219 231.808594 216.972656 231.703125 217.246094 C 231.621094 217.472656 231.515625 217.792969 231.390625 218.179688 C 230.308594 221.464844 229.078125 224.742188 226.976562 225.550781 C 226.199219 225.851562 225.386719 225.785156 224.625 225.355469 C 223.613281 224.78125 222.789062 223.609375 222.019531 221.660156 C 221.597656 220.582031 221.238281 219.488281 220.871094 218.390625 C 220.425781 217.050781 219.96875 215.664062 219.402344 214.347656 C 218.957031 213.324219 217.847656 212.863281 216.433594 213.113281 C 213.496094 213.636719 213.003906 216.605469 212.589844 221.074219 C 212.515625 221.851562 212.445312 222.613281 212.347656 223.332031 C 212.335938 223.542969 211.816406 230.101562 211.484375 232.1875 C 210.566406 237.90625 209.359375 240.160156 207.355469 239.996094 C 202.410156 239.574219 200.140625 217.882812 200.261719 208.71875 C 200.355469 201.722656 199.089844 199.167969 198.332031 198.761719 C 198.253906 198.726562 198.132812 198.660156 197.84375 198.863281 C 196.949219 199.46875 196.152344 201.355469 196.398438 203.335938 C 199.121094 224.902344 197.113281 249.601562 192.195312 255.164062 C 190.644531 256.914062 188.535156 256.890625 187.066406 255.414062 C 182.769531 251.101562 182.589844 233.566406 182.792969 207.304688 C 182.910156 192.953125 183.0625 173.296875 180.777344 171.746094 C 178.542969 172.671875 178.324219 188.910156 178.175781 199.660156 C 178.003906 212.167969 177.828125 225.109375 175.792969 231.699219 C 175.1875 233.652344 174.40625 235.441406 172.839844 235.296875 C 170.621094 235.101562 169.910156 231.605469 168.253906 217.808594 C 167.566406 212.078125 166.855469 206.15625 166.023438 203.863281 C 165.917969 203.574219 165.824219 203.34375 165.738281 203.164062 C 164.855469 205.167969 163.832031 210.675781 163.121094 214.5 C 162.136719 219.78125 161.207031 224.769531 160.039062 226.945312 C 159.140625 228.617188 157.714844 230.796875 155.726562 230.375 C 153.011719 229.804688 152.199219 224.332031 151.957031 221.121094 C 151.953125 194.105469 148.421875 190.960938 147.714844 190.605469 L 147.601562 190.691406 L 147.425781 190.652344 C 144.90625 191.753906 144.769531 200.515625 144.636719 208.988281 C 144.539062 215.203125 144.429688 222.246094 143.523438 228.835938 C 142.347656 237.378906 140.9375 239.042969 139.160156 238.925781 C 135.078125 238.648438 134.960938 224.617188 134.960938 223.019531 C 134.960938 222.519531 134.976562 221.929688 134.992188 221.277344 C 135.070312 218.011719 135.210938 211.9375 133.203125 210.023438 C 132.9375 209.769531 132.5625 209.476562 132.269531 209.558594 C 130.839844 209.917969 129.351562 214.5625 128.867188 216.089844 C 128.710938 216.570312 128.578125 216.972656 128.480469 217.246094 C 128.394531 217.46875 128.289062 217.789062 128.164062 218.175781 C 127.082031 221.460938 125.851562 224.742188 123.753906 225.550781 C 122.972656 225.851562 122.15625 225.785156 121.398438 225.355469 C 120.386719 224.78125 119.558594 223.609375 118.792969 221.660156 C 118.371094 220.582031 118.007812 219.488281 117.644531 218.390625 C 117.199219 217.050781 116.738281 215.664062 116.171875 214.347656 C 115.730469 213.324219 114.617188 212.863281 113.203125 213.113281 C 109.820312 213.714844 109.019531 217.910156 108.375 222.917969 L 108.261719 223.808594 L 105.703125 223.46875 L 105.824219 222.59375 C 106.382812 218.203125 107.234375 211.566406 112.753906 210.589844 C 115.351562 210.128906 117.621094 211.207031 118.535156 213.332031 C 119.148438 214.753906 119.628906 216.191406 120.089844 217.585938 C 120.433594 218.636719 120.785156 219.6875 121.191406 220.726562 C 121.90625 222.539062 122.460938 223.007812 122.667969 223.121094 C 123.960938 222.71875 125.28125 218.699219 125.71875 217.375 C 125.855469 216.949219 125.972656 216.597656 126.066406 216.347656 C 126.15625 216.101562 126.273438 215.742188 126.414062 215.308594 C 127.578125 211.667969 129.039062 207.726562 131.632812 207.070312 C 132.425781 206.867188 133.652344 206.894531 134.984375 208.167969 C 137.8125 210.867188 137.664062 217.167969 137.566406 221.339844 C 137.550781 221.964844 137.535156 222.535156 137.535156 223.019531 C 137.535156 229.675781 138.523438 234.328125 139.277344 235.925781 C 139.667969 235.109375 140.335938 233.132812 140.972656 228.488281 C 141.855469 222.050781 141.96875 215.089844 142.0625 208.949219 C 142.234375 198.082031 142.355469 190.203125 146.289062 188.351562 C 146.875 187.992188 147.847656 187.796875 148.875 188.316406 C 152.679688 190.230469 154.527344 200.929688 154.527344 221.023438 C 154.765625 224.128906 155.601562 227.398438 156.289062 227.867188 C 156.292969 227.796875 156.851562 227.453125 157.769531 225.734375 C 158.75 223.910156 159.726562 218.660156 160.585938 214.03125 C 162.488281 203.828125 163.351562 200.246094 165.601562 200.058594 C 167.316406 199.890625 168.109375 202.070312 168.441406 202.988281 C 169.378906 205.558594 170.074219 211.359375 170.808594 217.503906 C 171.382812 222.269531 172.199219 229.074219 173.03125 231.828125 C 173.121094 231.585938 173.222656 231.296875 173.332031 230.941406 C 175.257812 224.703125 175.433594 211.957031 175.601562 199.625 C 175.835938 182.496094 176.136719 171.882812 179.261719 169.667969 C 179.957031 169.175781 180.804688 169.054688 181.632812 169.332031 C 185.292969 170.546875 185.574219 181.277344 185.367188 207.328125 C 185.21875 226.21875 185.035156 249.730469 188.894531 253.605469 C 189.230469 253.945312 189.46875 253.945312 189.554688 253.945312 C 189.734375 253.945312 189.992188 253.773438 190.265625 253.464844 C 194.171875 249.046875 196.644531 225.847656 193.84375 203.660156 C 193.496094 200.898438 194.5625 197.996094 196.382812 196.746094 C 197.386719 196.054688 198.542969 195.964844 199.542969 196.5 C 201.820312 197.710938 202.925781 201.832031 202.835938 208.753906 C 202.675781 220.839844 205.578125 234.984375 207.472656 237.242188 C 207.773438 236.742188 208.367188 235.371094 208.9375 231.78125 C 209.257812 229.796875 209.785156 223.128906 209.792969 223.0625 C 209.886719 222.308594 209.957031 221.578125 210.023438 220.835938 C 210.414062 216.671875 210.894531 211.492188 215.980469 210.589844 C 218.574219 210.128906 220.84375 211.203125 221.761719 213.332031 C 222.375 214.753906 222.851562 216.191406 223.3125 217.585938 C 223.664062 218.636719 224.015625 219.6875 224.421875 220.726562 C 225.132812 222.539062 225.691406 223.007812 225.894531 223.121094 C 227.1875 222.71875 228.511719 218.699219 228.945312 217.378906 C 229.085938 216.953125 229.203125 216.597656 229.292969 216.347656 C 229.386719 216.105469 229.5 215.742188 229.636719 215.308594 C 230.804688 211.667969 232.265625 207.726562 234.863281 207.070312 C 235.648438 206.867188 236.878906 206.894531 238.210938 208.167969 C 241.039062 210.867188 240.890625 217.167969 240.796875 221.339844 C 240.777344 221.964844 240.761719 222.535156 240.761719 223.019531 C 240.761719 229.675781 241.75 234.328125 242.503906 235.925781 C 242.890625 235.109375 243.558594 233.132812 244.203125 228.488281 C 245.085938 222.050781 245.191406 215.089844 245.292969 208.949219 C 245.460938 198.082031 245.582031 190.203125 249.515625 188.351562 C 250.101562 187.992188 251.074219 187.796875 252.105469 188.316406 C 255.90625 190.230469 257.757812 200.929688 257.757812 221.023438 C 257.996094 224.128906 258.832031 227.398438 259.515625 227.867188 C 259.523438 227.796875 260.074219 227.453125 261 225.734375 C 261.980469 223.910156 262.953125 218.660156 263.816406 214.03125 C 265.710938 203.828125 266.578125 200.246094 268.828125 200.058594 C 270.546875 199.890625 271.339844 202.070312 271.671875 202.988281 C 272.605469 205.558594 273.300781 211.359375 274.042969 217.503906 C 274.609375 222.269531 275.425781 229.074219 276.261719 231.828125 C 276.347656 231.585938 276.449219 231.296875 276.558594 230.941406 C 278.484375 224.703125 278.65625 211.957031 278.828125 199.625 C 279.058594 182.496094 279.363281 171.882812 282.488281 169.667969 C 283.1875 169.175781 284.03125 169.054688 284.859375 169.332031 C 288.523438 170.546875 288.804688 181.277344 288.59375 207.328125 C 288.445312 226.21875 288.261719 249.730469 292.117188 253.605469 C 292.460938 253.945312 292.695312 253.945312 292.785156 253.945312 C 292.960938 253.945312 293.21875 253.773438 293.488281 253.464844 C 297.402344 249.046875 299.871094 225.847656 297.070312 203.660156 C 296.707031 200.769531 297.527344 197.855469 299.023438 196.734375 C 299.777344 196.164062 300.695312 196.046875 301.539062 196.402344 C 303.71875 197.332031 305.195312 201.316406 306.054688 208.589844 C 306.414062 211.636719 306.734375 214.929688 307.042969 218.179688 C 307.722656 225.273438 308.644531 234.832031 309.890625 236.933594 C 310.273438 236.445312 311.054688 235.125 312.214844 231.585938 L 314.664062 232.386719 C 312.863281 237.859375 311.453125 239.921875 309.617188 239.710938 C 306.761719 239.394531 305.9375 233.625 304.480469 218.425781 C 304.171875 215.191406 303.855469 211.917969 303.496094 208.886719 C 302.402344 199.609375 300.542969 198.769531 300.523438 198.761719 C 300.160156 198.945312 299.316406 200.875 299.628906 203.335938 C 302.34375 224.902344 300.34375 249.605469 295.421875 255.164062 C 294.628906 256.058594 293.738281 256.511719 292.785156 256.511719 " fill-opacity="1" fill-rule="nonzero"/></g></svg> | |
| ```` | |
| ## File: web/public/vite.svg | |
| ```` | |
| <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg> | |
| ```` | |
| ## File: web/src/app/components/telegram/ngx-telegram-widget.component.ts | |
| ````typescript | |
| import { | |
| AfterViewInit, | |
| ChangeDetectionStrategy, | |
| ChangeDetectorRef, | |
| Component, | |
| ElementRef, | |
| Input, | |
| output, | |
| Renderer2, | |
| ViewChild, | |
| } from '@angular/core'; | |
| import { WINDOW } from '../../utils/window'; | |
| export const NgxTelegramWidgetCallback = 'NgxTelegramWidgetCallback'; | |
| @Component({ | |
| selector: 'ngx-telegram-widget', | |
| standalone: true, | |
| template: ` <span ngSkipHydration #button></span> `, | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| }) | |
| export class NgxTelegramWidgetComponent implements AfterViewInit { | |
| @Input({ required: true }) botName = 'SampleBot'; | |
| @Input() buttonSize: string = 'large'; | |
| @Input() showUserPhoto: boolean = false; | |
| @Input() useCustomCorners: boolean = false; | |
| @Input() cornerRadius: number = 20; | |
| @Input() requestMessageAccess: boolean = false; | |
| @Input() redirectURL: string = ''; | |
| onAuth = output<unknown>(); | |
| @ViewChild('button', { static: true }) | |
| button!: ElementRef; | |
| constructor( | |
| private renderer: Renderer2, | |
| private readonly changeDetectorRef: ChangeDetectorRef | |
| ) {} | |
| ngAfterViewInit(): void { | |
| const s = this.renderer.createElement('script'); | |
| s.type = 'text/javascript'; | |
| s.src = 'https://telegram.org/js/telegram-widget.js?122'; | |
| s.setAttribute('data-telegram-login', this.botName); | |
| if (this.buttonSize) { | |
| s.setAttribute('data-size', this.buttonSize); | |
| } | |
| if (this.showUserPhoto) { | |
| s.setAttribute('data-userpic', this.showUserPhoto); | |
| } | |
| if (this.redirectURL) { | |
| s.setAttribute('data-auth-url', this.redirectURL); | |
| } | |
| s.setAttribute( | |
| 'data-request-access', | |
| this.requestMessageAccess ? 'write' : null | |
| ); | |
| s.setAttribute( | |
| 'data-radius', | |
| this.useCustomCorners ? this.cornerRadius : 20 | |
| ); | |
| if (this.onAuth !== undefined) { | |
| if (WINDOW) { | |
| WINDOW[NgxTelegramWidgetCallback] = (params: unknown) => | |
| this.onAuth && this.onAuth.emit(params); | |
| s.setAttribute('data-onauth', 'NgxTelegramWidgetCallback(user)'); | |
| } | |
| } | |
| this.button.nativeElement.parentElement.replaceChild( | |
| s, | |
| this.button.nativeElement | |
| ); | |
| this.changeDetectorRef.markForCheck(); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/components/theme/color-scheme-switcher.component.ts | |
| ````typescript | |
| import { ChangeDetectionStrategy, Component, inject } from '@angular/core'; | |
| import { AsyncPipe } from '@angular/common'; | |
| import { map } from 'rxjs'; | |
| import { ThemeService } from '../../services/theme.service'; | |
| @Component({ | |
| selector: 'color-scheme-switcher', | |
| imports: [AsyncPipe], | |
| standalone: true, | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| template: ` | |
| @if(theme$|async ; as theme){ | |
| <a [ariaLabel]="theme" (click)="switchTheme()"> | |
| @switch (theme) { @case ('light') { | |
| <svg | |
| xmlns="http://www.w3.org/2000/svg" | |
| width="1em" | |
| height="1em" | |
| viewBox="0 0 24 24" | |
| strokeWidth="2" | |
| stroke="currentColor" | |
| fill="none" | |
| strokeLinecap="round" | |
| strokeLinejoin="round" | |
| > | |
| <path stroke="none" d="M0 0h24v24H0z" fill="none" /> | |
| <path | |
| d="M12 1.992a10 10 0 1 0 9.236 13.838c.341 -.82 -.476 -1.644 -1.298 -1.31a6.5 6.5 0 0 1 -6.864 -10.787l.077 -.08c.551 -.63 .113 -1.653 -.758 -1.653h-.266l-.068 -.006l-.06 -.002z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| </svg> | |
| } @case ('dark') { | |
| <svg | |
| xmlns="http://www.w3.org/2000/svg" | |
| width="1em" | |
| height="1em" | |
| viewBox="0 0 24 24" | |
| strokeWidth="2" | |
| stroke="currentColor" | |
| fill="none" | |
| strokeLinecap="round" | |
| strokeLinejoin="round" | |
| > | |
| <path stroke="none" d="M0 0h24v24H0z" fill="none" /> | |
| <path | |
| d="M12 19a1 1 0 0 1 .993 .883l.007 .117v1a1 1 0 0 1 -1.993 .117l-.007 -.117v-1a1 1 0 0 1 1 -1z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M18.313 16.91l.094 .083l.7 .7a1 1 0 0 1 -1.32 1.497l-.094 -.083l-.7 -.7a1 1 0 0 1 1.218 -1.567l.102 .07z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M7.007 16.993a1 1 0 0 1 .083 1.32l-.083 .094l-.7 .7a1 1 0 0 1 -1.497 -1.32l.083 -.094l.7 -.7a1 1 0 0 1 1.414 0z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M4 11a1 1 0 0 1 .117 1.993l-.117 .007h-1a1 1 0 0 1 -.117 -1.993l.117 -.007h1z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M21 11a1 1 0 0 1 .117 1.993l-.117 .007h-1a1 1 0 0 1 -.117 -1.993l.117 -.007h1z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M6.213 4.81l.094 .083l.7 .7a1 1 0 0 1 -1.32 1.497l-.094 -.083l-.7 -.7a1 1 0 0 1 1.217 -1.567l.102 .07z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M19.107 4.893a1 1 0 0 1 .083 1.32l-.083 .094l-.7 .7a1 1 0 0 1 -1.497 -1.32l.083 -.094l.7 -.7a1 1 0 0 1 1.414 0z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M12 2a1 1 0 0 1 .993 .883l.007 .117v1a1 1 0 0 1 -1.993 .117l-.007 -.117v-1a1 1 0 0 1 1 -1z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| <path | |
| d="M12 7a5 5 0 1 1 -4.995 5.217l-.005 -.217l.005 -.217a5 5 0 0 1 4.995 -4.783z" | |
| strokeWidth="0" | |
| fill="currentColor" | |
| /> | |
| </svg> | |
| } } | |
| </a> | |
| } | |
| `, | |
| }) | |
| export class ColorSchemeSwitcherComponent { | |
| readonly themeService = inject(ThemeService); | |
| theme$ = this.themeService.stream$; | |
| themeLabel$ = this.themeService.stream$.pipe( | |
| map((theme) => | |
| theme === 'dark' ? 'Switch to Light Mode' : 'Switch to Dark Mode' | |
| ) | |
| ); | |
| switchTheme(): void { | |
| this.themeService.switchTheme(); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/directives/ if-logged.directive.ts | |
| ````typescript | |
| // if-logged.directive.ts | |
| import { | |
| Directive, | |
| Input, | |
| OnDestroy, | |
| OnInit, | |
| TemplateRef, | |
| ViewContainerRef, | |
| } from '@angular/core'; | |
| import { takeUntilDestroyed } from '@angular/core/rxjs-interop'; | |
| import { Subscription } from 'rxjs'; | |
| import { ProfileService } from '../services/profile.service'; | |
| @Directive({ | |
| selector: '[ifLogged]', | |
| }) | |
| export class IfLoggedDirective implements OnInit, OnDestroy { | |
| private subscription: Subscription | null = null; | |
| private hasView = false; | |
| constructor( | |
| private readonly templateRef: TemplateRef<any>, | |
| private readonly viewContainer: ViewContainerRef, | |
| private readonly profileService: ProfileService | |
| ) {} | |
| ngOnInit() { | |
| this.subscription = this.profileService | |
| .isLoggedIn() | |
| .subscribe((isLoggedIn) => { | |
| if (isLoggedIn && !this.hasView) { | |
| this.viewContainer.createEmbeddedView(this.templateRef); | |
| this.hasView = true; | |
| } else { | |
| if (!isLoggedIn && this.hasView) { | |
| this.viewContainer.clear(); | |
| this.hasView = false; | |
| } | |
| } | |
| }); | |
| } | |
| ngOnDestroy() { | |
| if (this.subscription) { | |
| this.subscription.unsubscribe(); // Предотвращаем утечку памяти | |
| } | |
| } | |
| @Input() set ifLogged(condition: any) { | |
| // null | |
| } | |
| } | |
| @Directive({ | |
| selector: '[ifNotLogged]', | |
| }) | |
| export class IfNotLoggedDirective implements OnInit, OnDestroy { | |
| private subscription: Subscription | null = null; | |
| private hasView = false; | |
| constructor( | |
| private readonly templateRef: TemplateRef<any>, | |
| private readonly viewContainer: ViewContainerRef, | |
| private readonly profileService: ProfileService | |
| ) {} | |
| ngOnInit() { | |
| this.subscription = this.profileService | |
| .isLoggedIn() | |
| .subscribe((isLoggedIn) => { | |
| if (!isLoggedIn && !this.hasView) { | |
| this.viewContainer.createEmbeddedView(this.templateRef); | |
| this.hasView = true; | |
| } else { | |
| if (isLoggedIn && this.hasView) { | |
| this.viewContainer.clear(); | |
| this.hasView = false; | |
| } | |
| } | |
| }); | |
| } | |
| ngOnDestroy() { | |
| if (this.subscription) { | |
| this.subscription.unsubscribe(); // Предотвращаем утечку памяти | |
| } | |
| } | |
| @Input() set ifNotLogged(condition: any) { | |
| // null | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/internal/class.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * Please import the `PrismaClient` class from the `client.ts` file instead. | |
| */ | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import type * as Prisma from "./prismaNamespace" | |
| const config: runtime.GetPrismaClientConfig = { | |
| "generator": { | |
| "name": "client1", | |
| "provider": { | |
| "fromEnvVar": null, | |
| "value": "prisma-client" | |
| }, | |
| "output": { | |
| "value": "/home/endy/Projects/site15/my-dashboard/web/src/app/generated/prisma", | |
| "fromEnvVar": null | |
| }, | |
| "config": { | |
| "engineType": "client" | |
| }, | |
| "binaryTargets": [ | |
| { | |
| "fromEnvVar": null, | |
| "value": "debian-openssl-3.0.x", | |
| "native": true | |
| } | |
| ], | |
| "previewFeatures": [], | |
| "sourceFilePath": "/home/endy/Projects/site15/my-dashboard/web/prisma/schema.prisma", | |
| "isCustomOutput": true | |
| }, | |
| "relativePath": "../../../../prisma", | |
| "clientVersion": "6.19.0", | |
| "engineVersion": "2ba551f319ab1df4bc874a89965d8b3641056773", | |
| "datasourceNames": [ | |
| "db" | |
| ], | |
| "activeProvider": "postgresql", | |
| "postinstall": false, | |
| "inlineDatasources": { | |
| "db": { | |
| "url": { | |
| "fromEnvVar": "MY_DASHBOARD_DATABASE_POSTGRES_URL", | |
| "value": null | |
| } | |
| } | |
| }, | |
| "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\n// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?\n// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init\n\ngenerator client1 {\n provider = \"prisma-client\"\n output = \"../src/app/generated/prisma\"\n engineType = \"client\"\n}\n\ngenerator client2 {\n provider = \"prisma-client\"\n output = \"../src/server/generated/prisma\"\n engineType = \"client\"\n}\n\ndatasource db {\n provider = \"postgresql\"\n url = env(\"MY_DASHBOARD_DATABASE_POSTGRES_URL\")\n}\n\nmodel User {\n id String @id(map: \"PK_USER\") @default(uuid()) @db.Uuid\n anonymousId String?\n telegramUserId String?\n telegramUserData Json?\n isBlackTheme Boolean?\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n Session Session[]\n Dashboard Dashboard[]\n\n @@unique([telegramUserId], map: \"UQ_USER\")\n}\n\nmodel Session {\n id String @id(map: \"PK_SESSION\") @default(uuid()) @db.Uuid\n userId String @db.Uuid\n User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_SESSION__USER_ID\")\n createdAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([userId], map: \"IDX_SESSION__USER_ID\")\n}\n\nmodel Dashboard {\n id String @id(map: \"PK_DASHBOARD\") @default(uuid()) @db.Uuid\n name String\n deviceId String?\n userId String @db.Uuid\n isBlackTheme Boolean?\n User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_DASHBOARD__USER_ID\")\n Widget Widget[]\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@unique([userId, name], map: \"UQ_DASHBOARD__USER_ID_NAME\")\n @@unique([deviceId], map: \"UQ_DASHBOARD__DEVICE_ID\")\n @@index([userId], map: \"IDX_DASHBOARD__USER_ID\")\n}\n\nmodel Widget {\n id String @id(map: \"PK_WIDGET\") @default(uuid()) @db.Uuid\n options Json?\n state Json?\n columnIndex Int?\n rowIndex Int?\n columnCount Int?\n rowCount Int?\n\n isBlackTheme Boolean?\n backgroundColor String?\n primaryColor String?\n positiveColor String?\n negativeColor String?\n // contrastMultiplier Float\n // textSaturationMultiplier Float\n\n dashboardId String @db.Uuid\n Dashboard Dashboard @relation(fields: [dashboardId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_WIDGET__DASHBOARD_ID\")\n WidgetLog WidgetLog[]\n\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([dashboardId], map: \"IDX_WIDGET__DASHBOARD_ID\")\n}\n\nmodel WidgetLog {\n id String @id(map: \"PK_WIDGET_LOG\") @default(uuid()) @db.Uuid\n oldOptions Json?\n newOptions Json?\n oldState Json?\n newState Json?\n\n widgetId String @db.Uuid\n Widget Widget @relation(fields: [widgetId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_WIDGET_LOG__WIDGET_ID\")\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([widgetId], map: \"IDX_WIDGET_LOG__WIDGET_ID\")\n}\n", | |
| "inlineSchemaHash": "aeef395d84970501273720149484679e38b6223b1abad17440ba39f57339891d", | |
| "copyEngine": true, | |
| "runtimeDataModel": { | |
| "models": {}, | |
| "enums": {}, | |
| "types": {} | |
| }, | |
| "dirname": "" | |
| } | |
| config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"anonymousId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"telegramUserId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"telegramUserData\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"Session\",\"kind\":\"object\",\"type\":\"Session\",\"relationName\":\"SessionToUser\"},{\"name\":\"Dashboard\",\"kind\":\"object\",\"type\":\"Dashboard\",\"relationName\":\"DashboardToUser\"}],\"dbName\":null},\"Session\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"User\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SessionToUser\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"Dashboard\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"name\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"deviceId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"User\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"DashboardToUser\"},{\"name\":\"Widget\",\"kind\":\"object\",\"type\":\"Widget\",\"relationName\":\"DashboardToWidget\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"Widget\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"options\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"state\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"columnIndex\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"rowIndex\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"columnCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"rowCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"backgroundColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"primaryColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"positiveColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"negativeColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"dashboardId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"Dashboard\",\"kind\":\"object\",\"type\":\"Dashboard\",\"relationName\":\"DashboardToWidget\"},{\"name\":\"WidgetLog\",\"kind\":\"object\",\"type\":\"WidgetLog\",\"relationName\":\"WidgetToWidgetLog\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"WidgetLog\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"oldOptions\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"newOptions\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"oldState\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"newState\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"widgetId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"Widget\",\"kind\":\"object\",\"type\":\"Widget\",\"relationName\":\"WidgetToWidgetLog\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null}},\"enums\":{},\"types\":{}}") | |
| config.engineWasm = undefined | |
| async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> { | |
| const { Buffer } = await import('node:buffer') | |
| const wasmArray = Buffer.from(wasmBase64, 'base64') | |
| return new WebAssembly.Module(wasmArray) | |
| } | |
| config.compilerWasm = { | |
| getRuntime: async () => await import("@prisma/client/runtime/query_compiler_bg.postgresql.mjs"), | |
| getQueryCompilerWasmModule: async () => { | |
| const { wasm } = await import("@prisma/client/runtime/query_compiler_bg.postgresql.wasm-base64.mjs") | |
| return await decodeBase64AsWasm(wasm) | |
| } | |
| } | |
| export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> = | |
| 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never | |
| export interface PrismaClientConstructor { | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| new < | |
| Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, | |
| LogOpts extends LogOptions<Options> = LogOptions<Options>, | |
| OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends { omit: infer U } ? U : Prisma.PrismaClientOptions['omit'], | |
| ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs | |
| >(options?: Prisma.Subset<Options, Prisma.PrismaClientOptions> ): PrismaClient<LogOpts, OmitOpts, ExtArgs> | |
| } | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| export interface PrismaClient< | |
| in LogOpts extends Prisma.LogLevel = never, | |
| in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = Prisma.PrismaClientOptions['omit'], | |
| in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs | |
| > { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] } | |
| $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient; | |
| /** | |
| * Connect with the database | |
| */ | |
| $connect(): runtime.Types.Utils.JsPromise<void>; | |
| /** | |
| * Disconnect from the database | |
| */ | |
| $disconnect(): runtime.Types.Utils.JsPromise<void>; | |
| /** | |
| * Executes a prepared raw query and returns the number of affected rows. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'[email protected]'};` | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>; | |
| /** | |
| * Executes a raw query and returns the number of affected rows. | |
| * Susceptible to SQL injections, see documentation. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, '[email protected]') | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>; | |
| /** | |
| * Performs a prepared raw query and returns the `SELECT` data. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'[email protected]'};` | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>; | |
| /** | |
| * Performs a raw query and returns the `SELECT` data. | |
| * Susceptible to SQL injections, see documentation. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, '[email protected]') | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>; | |
| /** | |
| * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole. | |
| * @example | |
| * ``` | |
| * const [george, bob, alice] = await prisma.$transaction([ | |
| * prisma.user.create({ data: { name: 'George' } }), | |
| * prisma.user.create({ data: { name: 'Bob' } }), | |
| * prisma.user.create({ data: { name: 'Alice' } }), | |
| * ]) | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions). | |
| */ | |
| $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>> | |
| $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<R> | |
| $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, { | |
| extArgs: ExtArgs | |
| }>> | |
| /** | |
| * `prisma.user`: Exposes CRUD operations for the **User** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| */ | |
| get user(): Prisma.UserDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.session`: Exposes CRUD operations for the **Session** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Sessions | |
| * const sessions = await prisma.session.findMany() | |
| * ``` | |
| */ | |
| get session(): Prisma.SessionDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.dashboard`: Exposes CRUD operations for the **Dashboard** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Dashboards | |
| * const dashboards = await prisma.dashboard.findMany() | |
| * ``` | |
| */ | |
| get dashboard(): Prisma.DashboardDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.widget`: Exposes CRUD operations for the **Widget** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Widgets | |
| * const widgets = await prisma.widget.findMany() | |
| * ``` | |
| */ | |
| get widget(): Prisma.WidgetDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.widgetLog`: Exposes CRUD operations for the **WidgetLog** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany() | |
| * ``` | |
| */ | |
| get widgetLog(): Prisma.WidgetLogDelegate<ExtArgs, { omit: OmitOpts }>; | |
| } | |
| export function getPrismaClientClass(dirname: string): PrismaClientConstructor { | |
| config.dirname = dirname | |
| return runtime.getPrismaClient(config) as unknown as PrismaClientConstructor | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/internal/prismaNamespace.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * All exports from this file are wrapped under a `Prisma` namespace object in the client.ts file. | |
| * While this enables partial backward compatibility, it is not part of the stable public API. | |
| * | |
| * If you are looking for your Models, Enums, and Input Types, please import them from the respective | |
| * model files in the `model` directory! | |
| */ | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import type * as Prisma from "../models" | |
| import { type PrismaClient } from "./class" | |
| export type * from '../models' | |
| export type DMMF = typeof runtime.DMMF | |
| export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T> | |
| /** | |
| * Prisma Errors | |
| */ | |
| export const PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError | |
| export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError | |
| export const PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError | |
| export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError | |
| export const PrismaClientRustPanicError = runtime.PrismaClientRustPanicError | |
| export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError | |
| export const PrismaClientInitializationError = runtime.PrismaClientInitializationError | |
| export type PrismaClientInitializationError = runtime.PrismaClientInitializationError | |
| export const PrismaClientValidationError = runtime.PrismaClientValidationError | |
| export type PrismaClientValidationError = runtime.PrismaClientValidationError | |
| /** | |
| * Re-export of sql-template-tag | |
| */ | |
| export const sql = runtime.sqltag | |
| export const empty = runtime.empty | |
| export const join = runtime.join | |
| export const raw = runtime.raw | |
| export const Sql = runtime.Sql | |
| export type Sql = runtime.Sql | |
| /** | |
| * Decimal.js | |
| */ | |
| export const Decimal = runtime.Decimal | |
| export type Decimal = runtime.Decimal | |
| export type DecimalJsLike = runtime.DecimalJsLike | |
| /** | |
| * Metrics | |
| */ | |
| export type Metrics = runtime.Metrics | |
| export type Metric<T> = runtime.Metric<T> | |
| export type MetricHistogram = runtime.MetricHistogram | |
| export type MetricHistogramBucket = runtime.MetricHistogramBucket | |
| /** | |
| * Extensions | |
| */ | |
| export type Extension = runtime.Types.Extensions.UserArgs | |
| export const getExtensionContext = runtime.Extensions.getExtensionContext | |
| export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F> | |
| export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F> | |
| export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F> | |
| export type Exact<A, W> = runtime.Types.Public.Exact<A, W> | |
| export type PrismaVersion = { | |
| client: string | |
| engine: string | |
| } | |
| /** | |
| * Prisma Client JS version: 6.19.0 | |
| * Query Engine version: 2ba551f319ab1df4bc874a89965d8b3641056773 | |
| */ | |
| export const prismaVersion: PrismaVersion = { | |
| client: "6.19.0", | |
| engine: "2ba551f319ab1df4bc874a89965d8b3641056773" | |
| } | |
| /** | |
| * Utility Types | |
| */ | |
| export type Bytes = runtime.Bytes | |
| export type JsonObject = runtime.JsonObject | |
| export type JsonArray = runtime.JsonArray | |
| export type JsonValue = runtime.JsonValue | |
| export type InputJsonObject = runtime.InputJsonObject | |
| export type InputJsonArray = runtime.InputJsonArray | |
| export type InputJsonValue = runtime.InputJsonValue | |
| export const NullTypes = { | |
| DbNull: runtime.objectEnumValues.classes.DbNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.DbNull), | |
| JsonNull: runtime.objectEnumValues.classes.JsonNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.JsonNull), | |
| AnyNull: runtime.objectEnumValues.classes.AnyNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.AnyNull), | |
| } | |
| /** | |
| * Helper for filtering JSON entries that have `null` on the database (empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const DbNull = runtime.objectEnumValues.instances.DbNull | |
| /** | |
| * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const JsonNull = runtime.objectEnumValues.instances.JsonNull | |
| /** | |
| * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const AnyNull = runtime.objectEnumValues.instances.AnyNull | |
| type SelectAndInclude = { | |
| select: any | |
| include: any | |
| } | |
| type SelectAndOmit = { | |
| select: any | |
| omit: any | |
| } | |
| /** | |
| * From T, pick a set of properties whose keys are in the union K | |
| */ | |
| type Prisma__Pick<T, K extends keyof T> = { | |
| [P in K]: T[P]; | |
| }; | |
| export type Enumerable<T> = T | Array<T>; | |
| /** | |
| * Subset | |
| * @desc From `T` pick properties that exist in `U`. Simple version of Intersection | |
| */ | |
| export type Subset<T, U> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never; | |
| }; | |
| /** | |
| * SelectSubset | |
| * @desc From `T` pick properties that exist in `U`. Simple version of Intersection. | |
| * Additionally, it validates, if both select and include are present. If the case, it errors. | |
| */ | |
| export type SelectSubset<T, U> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never | |
| } & | |
| (T extends SelectAndInclude | |
| ? 'Please either choose `select` or `include`.' | |
| : T extends SelectAndOmit | |
| ? 'Please either choose `select` or `omit`.' | |
| : {}) | |
| /** | |
| * Subset + Intersection | |
| * @desc From `T` pick properties that exist in `U` and intersect `K` | |
| */ | |
| export type SubsetIntersection<T, U, K> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never | |
| } & | |
| K | |
| type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }; | |
| /** | |
| * XOR is needed to have a real mutually exclusive union type | |
| * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types | |
| */ | |
| export type XOR<T, U> = | |
| T extends object ? | |
| U extends object ? | |
| (Without<T, U> & U) | (Without<U, T> & T) | |
| : U : T | |
| /** | |
| * Is T a Record? | |
| */ | |
| type IsObject<T extends any> = T extends Array<any> | |
| ? False | |
| : T extends Date | |
| ? False | |
| : T extends Uint8Array | |
| ? False | |
| : T extends BigInt | |
| ? False | |
| : T extends object | |
| ? True | |
| : False | |
| /** | |
| * If it's T[], return T | |
| */ | |
| export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T | |
| /** | |
| * From ts-toolbelt | |
| */ | |
| type __Either<O extends object, K extends Key> = Omit<O, K> & | |
| { | |
| // Merge all but K | |
| [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities | |
| }[K] | |
| type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>> | |
| type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>> | |
| type _Either< | |
| O extends object, | |
| K extends Key, | |
| strict extends Boolean | |
| > = { | |
| 1: EitherStrict<O, K> | |
| 0: EitherLoose<O, K> | |
| }[strict] | |
| export type Either< | |
| O extends object, | |
| K extends Key, | |
| strict extends Boolean = 1 | |
| > = O extends unknown ? _Either<O, K, strict> : never | |
| export type Union = any | |
| export type PatchUndefined<O extends object, O1 extends object> = { | |
| [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K] | |
| } & {} | |
| /** Helper Types for "Merge" **/ | |
| export type IntersectOf<U extends Union> = ( | |
| U extends unknown ? (k: U) => void : never | |
| ) extends (k: infer I) => void | |
| ? I | |
| : never | |
| export type Overwrite<O extends object, O1 extends object> = { | |
| [K in keyof O]: K extends keyof O1 ? O1[K] : O[K]; | |
| } & {}; | |
| type _Merge<U extends object> = IntersectOf<Overwrite<U, { | |
| [K in keyof U]-?: At<U, K>; | |
| }>>; | |
| type Key = string | number | symbol; | |
| type AtStrict<O extends object, K extends Key> = O[K & keyof O]; | |
| type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never; | |
| export type At<O extends object, K extends Key, strict extends Boolean = 1> = { | |
| 1: AtStrict<O, K>; | |
| 0: AtLoose<O, K>; | |
| }[strict]; | |
| export type ComputeRaw<A extends any> = A extends Function ? A : { | |
| [K in keyof A]: A[K]; | |
| } & {}; | |
| export type OptionalFlat<O> = { | |
| [K in keyof O]?: O[K]; | |
| } & {}; | |
| type _Record<K extends keyof any, T> = { | |
| [P in K]: T; | |
| }; | |
| // cause typescript not to expand types and preserve names | |
| type NoExpand<T> = T extends unknown ? T : never; | |
| // this type assumes the passed object is entirely optional | |
| export type AtLeast<O extends object, K extends string> = NoExpand< | |
| O extends unknown | |
| ? | (K extends keyof O ? { [P in K]: O[P] } & O : O) | |
| | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O | |
| : never>; | |
| type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never; | |
| export type Strict<U extends object> = ComputeRaw<_Strict<U>>; | |
| /** End Helper Types for "Merge" **/ | |
| export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>; | |
| export type Boolean = True | False | |
| export type True = 1 | |
| export type False = 0 | |
| export type Not<B extends Boolean> = { | |
| 0: 1 | |
| 1: 0 | |
| }[B] | |
| export type Extends<A1 extends any, A2 extends any> = [A1] extends [never] | |
| ? 0 // anything `never` is false | |
| : A1 extends A2 | |
| ? 1 | |
| : 0 | |
| export type Has<U extends Union, U1 extends Union> = Not< | |
| Extends<Exclude<U1, U>, U1> | |
| > | |
| export type Or<B1 extends Boolean, B2 extends Boolean> = { | |
| 0: { | |
| 0: 0 | |
| 1: 1 | |
| } | |
| 1: { | |
| 0: 1 | |
| 1: 1 | |
| } | |
| }[B1][B2] | |
| export type Keys<U extends Union> = U extends unknown ? keyof U : never | |
| export type GetScalarType<T, O> = O extends object ? { | |
| [P in keyof T]: P extends keyof O | |
| ? O[P] | |
| : never | |
| } : never | |
| type FieldPaths< | |
| T, | |
| U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'> | |
| > = IsObject<T> extends True ? U : T | |
| export type GetHavingFields<T> = { | |
| [K in keyof T]: Or< | |
| Or<Extends<'OR', K>, Extends<'AND', K>>, | |
| Extends<'NOT', K> | |
| > extends True | |
| ? // infer is only needed to not hit TS limit | |
| // based on the brilliant idea of Pierre-Antoine Mills | |
| // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437 | |
| T[K] extends infer TK | |
| ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never> | |
| : never | |
| : {} extends FieldPaths<T[K]> | |
| ? never | |
| : K | |
| }[keyof T] | |
| /** | |
| * Convert tuple to union | |
| */ | |
| type _TupleToUnion<T> = T extends (infer E)[] ? E : never | |
| type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K> | |
| export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T | |
| /** | |
| * Like `Pick`, but additionally can also accept an array of keys | |
| */ | |
| export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>> | |
| /** | |
| * Exclude all keys with underscores | |
| */ | |
| export type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T | |
| export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType> | |
| type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType> | |
| export const ModelName = { | |
| User: 'User', | |
| Session: 'Session', | |
| Dashboard: 'Dashboard', | |
| Widget: 'Widget', | |
| WidgetLog: 'WidgetLog' | |
| } as const | |
| export type ModelName = (typeof ModelName)[keyof typeof ModelName] | |
| export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> { | |
| returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions> | |
| } | |
| export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = { | |
| globalOmitOptions: { | |
| omit: GlobalOmitOptions | |
| } | |
| meta: { | |
| modelProps: "user" | "session" | "dashboard" | "widget" | "widgetLog" | |
| txIsolationLevel: TransactionIsolationLevel | |
| } | |
| model: { | |
| User: { | |
| payload: Prisma.$UserPayload<ExtArgs> | |
| fields: Prisma.UserFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.UserFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.UserFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.UserFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| findMany: { | |
| args: Prisma.UserFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| create: { | |
| args: Prisma.UserCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| createMany: { | |
| args: Prisma.UserCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.UserCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.UserDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| update: { | |
| args: Prisma.UserUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.UserDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.UserUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.UserUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.UserAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateUser> | |
| } | |
| groupBy: { | |
| args: Prisma.UserGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.UserCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Session: { | |
| payload: Prisma.$SessionPayload<ExtArgs> | |
| fields: Prisma.SessionFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.SessionFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.SessionFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| findMany: { | |
| args: Prisma.SessionFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| create: { | |
| args: Prisma.SessionCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| createMany: { | |
| args: Prisma.SessionCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.SessionDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| update: { | |
| args: Prisma.SessionUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.SessionDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.SessionUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.SessionUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.SessionAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateSession> | |
| } | |
| groupBy: { | |
| args: Prisma.SessionGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.SessionGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.SessionCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.SessionCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Dashboard: { | |
| payload: Prisma.$DashboardPayload<ExtArgs> | |
| fields: Prisma.DashboardFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.DashboardFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.DashboardFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.DashboardFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.DashboardFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| findMany: { | |
| args: Prisma.DashboardFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| create: { | |
| args: Prisma.DashboardCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| createMany: { | |
| args: Prisma.DashboardCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.DashboardCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.DashboardDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| update: { | |
| args: Prisma.DashboardUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.DashboardDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.DashboardUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.DashboardUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.DashboardUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.DashboardAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateDashboard> | |
| } | |
| groupBy: { | |
| args: Prisma.DashboardGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.DashboardGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.DashboardCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.DashboardCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Widget: { | |
| payload: Prisma.$WidgetPayload<ExtArgs> | |
| fields: Prisma.WidgetFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.WidgetFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.WidgetFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.WidgetFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.WidgetFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| findMany: { | |
| args: Prisma.WidgetFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| create: { | |
| args: Prisma.WidgetCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| createMany: { | |
| args: Prisma.WidgetCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.WidgetCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.WidgetDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| update: { | |
| args: Prisma.WidgetUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.WidgetDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.WidgetUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.WidgetUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.WidgetUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.WidgetAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateWidget> | |
| } | |
| groupBy: { | |
| args: Prisma.WidgetGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.WidgetCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| WidgetLog: { | |
| payload: Prisma.$WidgetLogPayload<ExtArgs> | |
| fields: Prisma.WidgetLogFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.WidgetLogFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.WidgetLogFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.WidgetLogFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.WidgetLogFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| findMany: { | |
| args: Prisma.WidgetLogFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| create: { | |
| args: Prisma.WidgetLogCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| createMany: { | |
| args: Prisma.WidgetLogCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.WidgetLogCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.WidgetLogDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| update: { | |
| args: Prisma.WidgetLogUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.WidgetLogDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.WidgetLogUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.WidgetLogUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.WidgetLogUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.WidgetLogAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateWidgetLog> | |
| } | |
| groupBy: { | |
| args: Prisma.WidgetLogGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetLogGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.WidgetLogCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetLogCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| } | |
| } & { | |
| other: { | |
| payload: any | |
| operations: { | |
| $executeRaw: { | |
| args: [query: TemplateStringsArray | Sql, ...values: any[]], | |
| result: any | |
| } | |
| $executeRawUnsafe: { | |
| args: [query: string, ...values: any[]], | |
| result: any | |
| } | |
| $queryRaw: { | |
| args: [query: TemplateStringsArray | Sql, ...values: any[]], | |
| result: any | |
| } | |
| $queryRawUnsafe: { | |
| args: [query: string, ...values: any[]], | |
| result: any | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Enums | |
| */ | |
| export const TransactionIsolationLevel = runtime.makeStrictEnum({ | |
| ReadUncommitted: 'ReadUncommitted', | |
| ReadCommitted: 'ReadCommitted', | |
| RepeatableRead: 'RepeatableRead', | |
| Serializable: 'Serializable' | |
| } as const) | |
| export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] | |
| export const UserScalarFieldEnum = { | |
| id: 'id', | |
| anonymousId: 'anonymousId', | |
| telegramUserId: 'telegramUserId', | |
| telegramUserData: 'telegramUserData', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt' | |
| } as const | |
| export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum] | |
| export const SessionScalarFieldEnum = { | |
| id: 'id', | |
| userId: 'userId', | |
| createdAt: 'createdAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum] | |
| export const DashboardScalarFieldEnum = { | |
| id: 'id', | |
| name: 'name', | |
| deviceId: 'deviceId', | |
| userId: 'userId', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type DashboardScalarFieldEnum = (typeof DashboardScalarFieldEnum)[keyof typeof DashboardScalarFieldEnum] | |
| export const WidgetScalarFieldEnum = { | |
| id: 'id', | |
| options: 'options', | |
| state: 'state', | |
| columnIndex: 'columnIndex', | |
| rowIndex: 'rowIndex', | |
| columnCount: 'columnCount', | |
| rowCount: 'rowCount', | |
| isBlackTheme: 'isBlackTheme', | |
| backgroundColor: 'backgroundColor', | |
| primaryColor: 'primaryColor', | |
| positiveColor: 'positiveColor', | |
| negativeColor: 'negativeColor', | |
| dashboardId: 'dashboardId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetScalarFieldEnum = (typeof WidgetScalarFieldEnum)[keyof typeof WidgetScalarFieldEnum] | |
| export const WidgetLogScalarFieldEnum = { | |
| id: 'id', | |
| oldOptions: 'oldOptions', | |
| newOptions: 'newOptions', | |
| oldState: 'oldState', | |
| newState: 'newState', | |
| widgetId: 'widgetId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetLogScalarFieldEnum = (typeof WidgetLogScalarFieldEnum)[keyof typeof WidgetLogScalarFieldEnum] | |
| export const SortOrder = { | |
| asc: 'asc', | |
| desc: 'desc' | |
| } as const | |
| export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] | |
| export const NullableJsonNullValueInput = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull | |
| } as const | |
| export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput] | |
| export const QueryMode = { | |
| default: 'default', | |
| insensitive: 'insensitive' | |
| } as const | |
| export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode] | |
| export const JsonNullValueFilter = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull, | |
| AnyNull: AnyNull | |
| } as const | |
| export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter] | |
| export const NullsOrder = { | |
| first: 'first', | |
| last: 'last' | |
| } as const | |
| export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder] | |
| /** | |
| * Field references | |
| */ | |
| /** | |
| * Reference to a field of type 'String' | |
| */ | |
| export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'> | |
| /** | |
| * Reference to a field of type 'String[]' | |
| */ | |
| export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'> | |
| /** | |
| * Reference to a field of type 'Json' | |
| */ | |
| export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'> | |
| /** | |
| * Reference to a field of type 'QueryMode' | |
| */ | |
| export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'> | |
| /** | |
| * Reference to a field of type 'Boolean' | |
| */ | |
| export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'> | |
| /** | |
| * Reference to a field of type 'DateTime' | |
| */ | |
| export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'> | |
| /** | |
| * Reference to a field of type 'DateTime[]' | |
| */ | |
| export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'> | |
| /** | |
| * Reference to a field of type 'Int' | |
| */ | |
| export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'> | |
| /** | |
| * Reference to a field of type 'Int[]' | |
| */ | |
| export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'> | |
| /** | |
| * Reference to a field of type 'Float' | |
| */ | |
| export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'> | |
| /** | |
| * Reference to a field of type 'Float[]' | |
| */ | |
| export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'> | |
| /** | |
| * Batch Payload for updateMany & deleteMany & createMany | |
| */ | |
| export type BatchPayload = { | |
| count: number | |
| } | |
| export type Datasource = { | |
| url?: string | |
| } | |
| export type Datasources = { | |
| db?: Datasource | |
| } | |
| export const defineExtension = runtime.Extensions.defineExtension as unknown as runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs> | |
| export type DefaultPrismaClient = PrismaClient | |
| export type ErrorFormat = 'pretty' | 'colorless' | 'minimal' | |
| export interface PrismaClientOptions { | |
| /** | |
| * Overwrites the datasource url from your schema.prisma file | |
| */ | |
| datasources?: Datasources | |
| /** | |
| * Overwrites the datasource url from your schema.prisma file | |
| */ | |
| datasourceUrl?: string | |
| /** | |
| * @default "colorless" | |
| */ | |
| errorFormat?: ErrorFormat | |
| /** | |
| * @example | |
| * ``` | |
| * // Shorthand for `emit: 'stdout'` | |
| * log: ['query', 'info', 'warn', 'error'] | |
| * | |
| * // Emit as events only | |
| * log: [ | |
| * { emit: 'event', level: 'query' }, | |
| * { emit: 'event', level: 'info' }, | |
| * { emit: 'event', level: 'warn' } | |
| * { emit: 'event', level: 'error' } | |
| * ] | |
| * | |
| * / Emit as events and log to stdout | |
| * og: [ | |
| * { emit: 'stdout', level: 'query' }, | |
| * { emit: 'stdout', level: 'info' }, | |
| * { emit: 'stdout', level: 'warn' } | |
| * { emit: 'stdout', level: 'error' } | |
| * | |
| * ``` | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option). | |
| */ | |
| log?: (LogLevel | LogDefinition)[] | |
| /** | |
| * The default values for transactionOptions | |
| * maxWait ?= 2000 | |
| * timeout ?= 5000 | |
| */ | |
| transactionOptions?: { | |
| maxWait?: number | |
| timeout?: number | |
| isolationLevel?: TransactionIsolationLevel | |
| } | |
| /** | |
| * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale` | |
| */ | |
| adapter?: runtime.SqlDriverAdapterFactory | null | |
| /** | |
| * Global configuration for omitting model fields by default. | |
| * | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient({ | |
| * omit: { | |
| * user: { | |
| * password: true | |
| * } | |
| * } | |
| * }) | |
| * ``` | |
| */ | |
| omit?: GlobalOmitConfig | |
| } | |
| export type GlobalOmitConfig = { | |
| user?: Prisma.UserOmit | |
| session?: Prisma.SessionOmit | |
| dashboard?: Prisma.DashboardOmit | |
| widget?: Prisma.WidgetOmit | |
| widgetLog?: Prisma.WidgetLogOmit | |
| } | |
| /* Types for Logging */ | |
| export type LogLevel = 'info' | 'query' | 'warn' | 'error' | |
| export type LogDefinition = { | |
| level: LogLevel | |
| emit: 'stdout' | 'event' | |
| } | |
| export type CheckIsLogLevel<T> = T extends LogLevel ? T : never; | |
| export type GetLogType<T> = CheckIsLogLevel< | |
| T extends LogDefinition ? T['level'] : T | |
| >; | |
| export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition> | |
| ? GetLogType<T[number]> | |
| : never; | |
| export type QueryEvent = { | |
| timestamp: Date | |
| query: string | |
| params: string | |
| duration: number | |
| target: string | |
| } | |
| export type LogEvent = { | |
| timestamp: Date | |
| message: string | |
| target: string | |
| } | |
| /* End Types for Logging */ | |
| export type PrismaAction = | |
| | 'findUnique' | |
| | 'findUniqueOrThrow' | |
| | 'findMany' | |
| | 'findFirst' | |
| | 'findFirstOrThrow' | |
| | 'create' | |
| | 'createMany' | |
| | 'createManyAndReturn' | |
| | 'update' | |
| | 'updateMany' | |
| | 'updateManyAndReturn' | |
| | 'upsert' | |
| | 'delete' | |
| | 'deleteMany' | |
| | 'executeRaw' | |
| | 'queryRaw' | |
| | 'aggregate' | |
| | 'count' | |
| | 'runCommandRaw' | |
| | 'findRaw' | |
| | 'groupBy' | |
| /** | |
| * `PrismaClient` proxy available in interactive transactions. | |
| */ | |
| export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList> | |
| ```` | |
| ## File: web/src/app/generated/prisma/internal/prismaNamespaceBrowser.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file. | |
| * While this enables partial backward compatibility, it is not part of the stable public API. | |
| * | |
| * If you are looking for your Models, Enums, and Input Types, please import them from the respective | |
| * model files in the `model` directory! | |
| */ | |
| import * as runtime from "@prisma/client/runtime/index-browser" | |
| export type * from '../models' | |
| export type * from './prismaNamespace' | |
| export const Decimal = runtime.Decimal | |
| export const NullTypes = { | |
| DbNull: runtime.objectEnumValues.classes.DbNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.DbNull), | |
| JsonNull: runtime.objectEnumValues.classes.JsonNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.JsonNull), | |
| AnyNull: runtime.objectEnumValues.classes.AnyNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.AnyNull), | |
| } | |
| /** | |
| * Helper for filtering JSON entries that have `null` on the database (empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const DbNull = runtime.objectEnumValues.instances.DbNull | |
| /** | |
| * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const JsonNull = runtime.objectEnumValues.instances.JsonNull | |
| /** | |
| * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const AnyNull = runtime.objectEnumValues.instances.AnyNull | |
| export const ModelName = { | |
| User: 'User', | |
| Session: 'Session', | |
| Dashboard: 'Dashboard', | |
| Widget: 'Widget', | |
| WidgetLog: 'WidgetLog' | |
| } as const | |
| export type ModelName = (typeof ModelName)[keyof typeof ModelName] | |
| /* | |
| * Enums | |
| */ | |
| export const TransactionIsolationLevel = runtime.makeStrictEnum({ | |
| ReadUncommitted: 'ReadUncommitted', | |
| ReadCommitted: 'ReadCommitted', | |
| RepeatableRead: 'RepeatableRead', | |
| Serializable: 'Serializable' | |
| } as const) | |
| export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] | |
| export const UserScalarFieldEnum = { | |
| id: 'id', | |
| anonymousId: 'anonymousId', | |
| telegramUserId: 'telegramUserId', | |
| telegramUserData: 'telegramUserData', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt' | |
| } as const | |
| export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum] | |
| export const SessionScalarFieldEnum = { | |
| id: 'id', | |
| userId: 'userId', | |
| createdAt: 'createdAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum] | |
| export const DashboardScalarFieldEnum = { | |
| id: 'id', | |
| name: 'name', | |
| deviceId: 'deviceId', | |
| userId: 'userId', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type DashboardScalarFieldEnum = (typeof DashboardScalarFieldEnum)[keyof typeof DashboardScalarFieldEnum] | |
| export const WidgetScalarFieldEnum = { | |
| id: 'id', | |
| options: 'options', | |
| state: 'state', | |
| columnIndex: 'columnIndex', | |
| rowIndex: 'rowIndex', | |
| columnCount: 'columnCount', | |
| rowCount: 'rowCount', | |
| isBlackTheme: 'isBlackTheme', | |
| backgroundColor: 'backgroundColor', | |
| primaryColor: 'primaryColor', | |
| positiveColor: 'positiveColor', | |
| negativeColor: 'negativeColor', | |
| dashboardId: 'dashboardId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetScalarFieldEnum = (typeof WidgetScalarFieldEnum)[keyof typeof WidgetScalarFieldEnum] | |
| export const WidgetLogScalarFieldEnum = { | |
| id: 'id', | |
| oldOptions: 'oldOptions', | |
| newOptions: 'newOptions', | |
| oldState: 'oldState', | |
| newState: 'newState', | |
| widgetId: 'widgetId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetLogScalarFieldEnum = (typeof WidgetLogScalarFieldEnum)[keyof typeof WidgetLogScalarFieldEnum] | |
| export const SortOrder = { | |
| asc: 'asc', | |
| desc: 'desc' | |
| } as const | |
| export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] | |
| export const NullableJsonNullValueInput = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull | |
| } as const | |
| export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput] | |
| export const QueryMode = { | |
| default: 'default', | |
| insensitive: 'insensitive' | |
| } as const | |
| export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode] | |
| export const JsonNullValueFilter = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull, | |
| AnyNull: AnyNull | |
| } as const | |
| export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter] | |
| export const NullsOrder = { | |
| first: 'first', | |
| last: 'last' | |
| } as const | |
| export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder] | |
| ```` | |
| ## File: web/src/app/generated/prisma/models/Dashboard.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Dashboard` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type DashboardModel = runtime.Types.Result.DefaultSelection<Prisma.$DashboardPayload> | |
| export type AggregateDashboard = { | |
| _count: DashboardCountAggregateOutputType | null | |
| _min: DashboardMinAggregateOutputType | null | |
| _max: DashboardMaxAggregateOutputType | null | |
| } | |
| export type DashboardMinAggregateOutputType = { | |
| id: string | null | |
| name: string | null | |
| deviceId: string | null | |
| userId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type DashboardMaxAggregateOutputType = { | |
| id: string | null | |
| name: string | null | |
| deviceId: string | null | |
| userId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type DashboardCountAggregateOutputType = { | |
| id: number | |
| name: number | |
| deviceId: number | |
| userId: number | |
| isBlackTheme: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type DashboardMinAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type DashboardMaxAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type DashboardCountAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type DashboardAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Dashboard to aggregate. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Dashboards | |
| **/ | |
| _count?: true | DashboardCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: DashboardMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: DashboardMaxAggregateInputType | |
| } | |
| export type GetDashboardAggregateType<T extends DashboardAggregateArgs> = { | |
| [P in keyof T & keyof AggregateDashboard]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateDashboard[P]> | |
| : Prisma.GetScalarType<T[P], AggregateDashboard[P]> | |
| } | |
| export type DashboardGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.DashboardWhereInput | |
| orderBy?: Prisma.DashboardOrderByWithAggregationInput | Prisma.DashboardOrderByWithAggregationInput[] | |
| by: Prisma.DashboardScalarFieldEnum[] | Prisma.DashboardScalarFieldEnum | |
| having?: Prisma.DashboardScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: DashboardCountAggregateInputType | true | |
| _min?: DashboardMinAggregateInputType | |
| _max?: DashboardMaxAggregateInputType | |
| } | |
| export type DashboardGroupByOutputType = { | |
| id: string | |
| name: string | |
| deviceId: string | null | |
| userId: string | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: DashboardCountAggregateOutputType | null | |
| _min: DashboardMinAggregateOutputType | null | |
| _max: DashboardMaxAggregateOutputType | null | |
| } | |
| type GetDashboardGroupByPayload<T extends DashboardGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<DashboardGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof DashboardGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], DashboardGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], DashboardGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type DashboardWhereInput = { | |
| AND?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| OR?: Prisma.DashboardWhereInput[] | |
| NOT?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| id?: Prisma.UuidFilter<"Dashboard"> | string | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| Widget?: Prisma.WidgetListRelationFilter | |
| } | |
| export type DashboardOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| User?: Prisma.UserOrderByWithRelationInput | |
| Widget?: Prisma.WidgetOrderByRelationAggregateInput | |
| } | |
| export type DashboardWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| deviceId?: string | |
| userId_name?: Prisma.DashboardUserIdNameCompoundUniqueInput | |
| AND?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| OR?: Prisma.DashboardWhereInput[] | |
| NOT?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| Widget?: Prisma.WidgetListRelationFilter | |
| }, "id" | "userId_name" | "deviceId"> | |
| export type DashboardOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.DashboardCountOrderByAggregateInput | |
| _max?: Prisma.DashboardMaxOrderByAggregateInput | |
| _min?: Prisma.DashboardMinOrderByAggregateInput | |
| } | |
| export type DashboardScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.DashboardScalarWhereWithAggregatesInput | Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.DashboardScalarWhereWithAggregatesInput | Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Dashboard"> | string | |
| name?: Prisma.StringWithAggregatesFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableWithAggregatesFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidWithAggregatesFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Dashboard"> | Date | string | null | |
| } | |
| export type DashboardCreateInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutDashboardInput | |
| Widget?: Prisma.WidgetCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetUncheckedCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutDashboardNestedInput | |
| Widget?: Prisma.WidgetUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUncheckedUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardCreateManyInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardListRelationFilter = { | |
| every?: Prisma.DashboardWhereInput | |
| some?: Prisma.DashboardWhereInput | |
| none?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type DashboardUserIdNameCompoundUniqueInput = { | |
| userId: string | |
| name: string | |
| } | |
| export type DashboardCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardScalarRelationFilter = { | |
| is?: Prisma.DashboardWhereInput | |
| isNot?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| } | |
| export type DashboardUncheckedCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| } | |
| export type DashboardUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput | Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| set?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| disconnect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| delete?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| update?: Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput | Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.DashboardUpdateManyWithWhereWithoutUserInput | Prisma.DashboardUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| } | |
| export type DashboardUncheckedUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput | Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| set?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| disconnect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| delete?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| update?: Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput | Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.DashboardUpdateManyWithWhereWithoutUserInput | Prisma.DashboardUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| } | |
| export type DashboardCreateNestedOneWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutWidgetInput | |
| connect?: Prisma.DashboardWhereUniqueInput | |
| } | |
| export type DashboardUpdateOneRequiredWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutWidgetInput | |
| upsert?: Prisma.DashboardUpsertWithoutWidgetInput | |
| connect?: Prisma.DashboardWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.DashboardUpdateToOneWithWhereWithoutWidgetInput, Prisma.DashboardUpdateWithoutWidgetInput>, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type DashboardCreateWithoutUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateWithoutUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetUncheckedCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardCreateOrConnectWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | |
| } | |
| export type DashboardCreateManyUserInputEnvelope = { | |
| data: Prisma.DashboardCreateManyUserInput | Prisma.DashboardCreateManyUserInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type DashboardUpsertWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| update: Prisma.XOR<Prisma.DashboardUpdateWithoutUserInput, Prisma.DashboardUncheckedUpdateWithoutUserInput> | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | |
| } | |
| export type DashboardUpdateWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateWithoutUserInput, Prisma.DashboardUncheckedUpdateWithoutUserInput> | |
| } | |
| export type DashboardUpdateManyWithWhereWithoutUserInput = { | |
| where: Prisma.DashboardScalarWhereInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyWithoutUserInput> | |
| } | |
| export type DashboardScalarWhereInput = { | |
| AND?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| OR?: Prisma.DashboardScalarWhereInput[] | |
| NOT?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Dashboard"> | string | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| } | |
| export type DashboardCreateWithoutWidgetInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateWithoutWidgetInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardCreateOrConnectWithoutWidgetInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type DashboardUpsertWithoutWidgetInput = { | |
| update: Prisma.XOR<Prisma.DashboardUpdateWithoutWidgetInput, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| where?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardUpdateToOneWithWhereWithoutWidgetInput = { | |
| where?: Prisma.DashboardWhereInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateWithoutWidgetInput, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type DashboardUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardCreateManyUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUncheckedUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateManyWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| /** | |
| * Count Type DashboardCountOutputType | |
| */ | |
| export type DashboardCountOutputType = { | |
| Widget: number | |
| } | |
| export type DashboardCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | DashboardCountOutputTypeCountWidgetArgs | |
| } | |
| /** | |
| * DashboardCountOutputType without action | |
| */ | |
| export type DashboardCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the DashboardCountOutputType | |
| */ | |
| select?: Prisma.DashboardCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * DashboardCountOutputType without action | |
| */ | |
| export type DashboardCountOutputTypeCountWidgetArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetWhereInput | |
| } | |
| export type DashboardSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| Widget?: boolean | Prisma.Dashboard$WidgetArgs<ExtArgs> | |
| _count?: boolean | Prisma.DashboardCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectScalar = { | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type DashboardOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "name" | "deviceId" | "userId" | "isBlackTheme" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["dashboard"]> | |
| export type DashboardInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| Widget?: boolean | Prisma.Dashboard$WidgetArgs<ExtArgs> | |
| _count?: boolean | Prisma.DashboardCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type DashboardIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type DashboardIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type $DashboardPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Dashboard" | |
| objects: { | |
| User: Prisma.$UserPayload<ExtArgs> | |
| Widget: Prisma.$WidgetPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| name: string | |
| deviceId: string | null | |
| userId: string | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["dashboard"]> | |
| composites: {} | |
| } | |
| export type DashboardGetPayload<S extends boolean | null | undefined | DashboardDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$DashboardPayload, S> | |
| export type DashboardCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<DashboardFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: DashboardCountAggregateInputType | true | |
| } | |
| export interface DashboardDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Dashboard'], meta: { name: 'Dashboard' } } | |
| /** | |
| * Find zero or one Dashboard that matches the filter. | |
| * @param {DashboardFindUniqueArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends DashboardFindUniqueArgs>(args: Prisma.SelectSubset<T, DashboardFindUniqueArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Dashboard that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {DashboardFindUniqueOrThrowArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends DashboardFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, DashboardFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Dashboard that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindFirstArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends DashboardFindFirstArgs>(args?: Prisma.SelectSubset<T, DashboardFindFirstArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Dashboard that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindFirstOrThrowArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends DashboardFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, DashboardFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Dashboards that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Dashboards | |
| * const dashboards = await prisma.dashboard.findMany() | |
| * | |
| * // Get first 10 Dashboards | |
| * const dashboards = await prisma.dashboard.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends DashboardFindManyArgs>(args?: Prisma.SelectSubset<T, DashboardFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Dashboard. | |
| * @param {DashboardCreateArgs} args - Arguments to create a Dashboard. | |
| * @example | |
| * // Create one Dashboard | |
| * const Dashboard = await prisma.dashboard.create({ | |
| * data: { | |
| * // ... data to create a Dashboard | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends DashboardCreateArgs>(args: Prisma.SelectSubset<T, DashboardCreateArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Dashboards. | |
| * @param {DashboardCreateManyArgs} args - Arguments to create many Dashboards. | |
| * @example | |
| * // Create many Dashboards | |
| * const dashboard = await prisma.dashboard.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends DashboardCreateManyArgs>(args?: Prisma.SelectSubset<T, DashboardCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Dashboards and returns the data saved in the database. | |
| * @param {DashboardCreateManyAndReturnArgs} args - Arguments to create many Dashboards. | |
| * @example | |
| * // Create many Dashboards | |
| * const dashboard = await prisma.dashboard.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Dashboards and only return the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends DashboardCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, DashboardCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Dashboard. | |
| * @param {DashboardDeleteArgs} args - Arguments to delete one Dashboard. | |
| * @example | |
| * // Delete one Dashboard | |
| * const Dashboard = await prisma.dashboard.delete({ | |
| * where: { | |
| * // ... filter to delete one Dashboard | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends DashboardDeleteArgs>(args: Prisma.SelectSubset<T, DashboardDeleteArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Dashboard. | |
| * @param {DashboardUpdateArgs} args - Arguments to update one Dashboard. | |
| * @example | |
| * // Update one Dashboard | |
| * const dashboard = await prisma.dashboard.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends DashboardUpdateArgs>(args: Prisma.SelectSubset<T, DashboardUpdateArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Dashboards. | |
| * @param {DashboardDeleteManyArgs} args - Arguments to filter Dashboards to delete. | |
| * @example | |
| * // Delete a few Dashboards | |
| * const { count } = await prisma.dashboard.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends DashboardDeleteManyArgs>(args?: Prisma.SelectSubset<T, DashboardDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Dashboards. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Dashboards | |
| * const dashboard = await prisma.dashboard.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends DashboardUpdateManyArgs>(args: Prisma.SelectSubset<T, DashboardUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Dashboards and returns the data updated in the database. | |
| * @param {DashboardUpdateManyAndReturnArgs} args - Arguments to update many Dashboards. | |
| * @example | |
| * // Update many Dashboards | |
| * const dashboard = await prisma.dashboard.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Dashboards and only return the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends DashboardUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, DashboardUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Dashboard. | |
| * @param {DashboardUpsertArgs} args - Arguments to update or create a Dashboard. | |
| * @example | |
| * // Update or create a Dashboard | |
| * const dashboard = await prisma.dashboard.upsert({ | |
| * create: { | |
| * // ... data to create a Dashboard | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Dashboard we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends DashboardUpsertArgs>(args: Prisma.SelectSubset<T, DashboardUpsertArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Dashboards. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardCountArgs} args - Arguments to filter Dashboards to count. | |
| * @example | |
| * // Count the number of Dashboards | |
| * const count = await prisma.dashboard.count({ | |
| * where: { | |
| * // ... the filter for the Dashboards we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends DashboardCountArgs>( | |
| args?: Prisma.Subset<T, DashboardCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], DashboardCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Dashboard. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends DashboardAggregateArgs>(args: Prisma.Subset<T, DashboardAggregateArgs>): Prisma.PrismaPromise<GetDashboardAggregateType<T>> | |
| /** | |
| * Group by Dashboard. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends DashboardGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: DashboardGroupByArgs['orderBy'] } | |
| : { orderBy?: DashboardGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, DashboardGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDashboardGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Dashboard model | |
| */ | |
| readonly fields: DashboardFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Dashboard. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__DashboardClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| User<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| Widget<T extends Prisma.Dashboard$WidgetArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Dashboard$WidgetArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Dashboard model | |
| */ | |
| export interface DashboardFieldRefs { | |
| readonly id: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly name: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly deviceId: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly userId: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly isBlackTheme: Prisma.FieldRef<"Dashboard", 'Boolean'> | |
| readonly createdAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Dashboard findUnique | |
| */ | |
| export type DashboardFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard findUniqueOrThrow | |
| */ | |
| export type DashboardFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard findFirst | |
| */ | |
| export type DashboardFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Dashboards. | |
| */ | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard findFirstOrThrow | |
| */ | |
| export type DashboardFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Dashboards. | |
| */ | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard findMany | |
| */ | |
| export type DashboardFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboards to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard create | |
| */ | |
| export type DashboardCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Dashboard. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardCreateInput, Prisma.DashboardUncheckedCreateInput> | |
| } | |
| /** | |
| * Dashboard createMany | |
| */ | |
| export type DashboardCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Dashboards. | |
| */ | |
| data: Prisma.DashboardCreateManyInput | Prisma.DashboardCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Dashboard createManyAndReturn | |
| */ | |
| export type DashboardCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Dashboards. | |
| */ | |
| data: Prisma.DashboardCreateManyInput | Prisma.DashboardCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Dashboard update | |
| */ | |
| export type DashboardUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Dashboard. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateInput, Prisma.DashboardUncheckedUpdateInput> | |
| /** | |
| * Choose, which Dashboard to update. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard updateMany | |
| */ | |
| export type DashboardUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Dashboards. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Dashboards to update | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Dashboard updateManyAndReturn | |
| */ | |
| export type DashboardUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Dashboards. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Dashboards to update | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Dashboard upsert | |
| */ | |
| export type DashboardUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Dashboard to update in case it exists. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * In case the Dashboard found by the `where` argument doesn't exist, create a new Dashboard with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.DashboardCreateInput, Prisma.DashboardUncheckedCreateInput> | |
| /** | |
| * In case the Dashboard was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.DashboardUpdateInput, Prisma.DashboardUncheckedUpdateInput> | |
| } | |
| /** | |
| * Dashboard delete | |
| */ | |
| export type DashboardDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter which Dashboard to delete. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard deleteMany | |
| */ | |
| export type DashboardDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Dashboards to delete | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Dashboard.Widget | |
| */ | |
| export type Dashboard$WidgetArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| where?: Prisma.WidgetWhereInput | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard without action | |
| */ | |
| export type DashboardDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/models/Session.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Session` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type SessionModel = runtime.Types.Result.DefaultSelection<Prisma.$SessionPayload> | |
| export type AggregateSession = { | |
| _count: SessionCountAggregateOutputType | null | |
| _min: SessionMinAggregateOutputType | null | |
| _max: SessionMaxAggregateOutputType | null | |
| } | |
| export type SessionMinAggregateOutputType = { | |
| id: string | null | |
| userId: string | null | |
| createdAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type SessionMaxAggregateOutputType = { | |
| id: string | null | |
| userId: string | null | |
| createdAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type SessionCountAggregateOutputType = { | |
| id: number | |
| userId: number | |
| createdAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type SessionMinAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| } | |
| export type SessionMaxAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| } | |
| export type SessionCountAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type SessionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Session to aggregate. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Sessions | |
| **/ | |
| _count?: true | SessionCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: SessionMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: SessionMaxAggregateInputType | |
| } | |
| export type GetSessionAggregateType<T extends SessionAggregateArgs> = { | |
| [P in keyof T & keyof AggregateSession]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateSession[P]> | |
| : Prisma.GetScalarType<T[P], AggregateSession[P]> | |
| } | |
| export type SessionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.SessionWhereInput | |
| orderBy?: Prisma.SessionOrderByWithAggregationInput | Prisma.SessionOrderByWithAggregationInput[] | |
| by: Prisma.SessionScalarFieldEnum[] | Prisma.SessionScalarFieldEnum | |
| having?: Prisma.SessionScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: SessionCountAggregateInputType | true | |
| _min?: SessionMinAggregateInputType | |
| _max?: SessionMaxAggregateInputType | |
| } | |
| export type SessionGroupByOutputType = { | |
| id: string | |
| userId: string | |
| createdAt: Date | |
| deletedAt: Date | null | |
| _count: SessionCountAggregateOutputType | null | |
| _min: SessionMinAggregateOutputType | null | |
| _max: SessionMaxAggregateOutputType | null | |
| } | |
| type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<SessionGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type SessionWhereInput = { | |
| AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| OR?: Prisma.SessionWhereInput[] | |
| NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| id?: Prisma.UuidFilter<"Session"> | string | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| } | |
| export type SessionOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| User?: Prisma.UserOrderByWithRelationInput | |
| } | |
| export type SessionWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| OR?: Prisma.SessionWhereInput[] | |
| NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| }, "id"> | |
| export type SessionOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.SessionCountOrderByAggregateInput | |
| _max?: Prisma.SessionMaxOrderByAggregateInput | |
| _min?: Prisma.SessionMinOrderByAggregateInput | |
| } | |
| export type SessionScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.SessionScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Session"> | string | |
| userId?: Prisma.UuidWithAggregatesFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Session"> | Date | string | null | |
| } | |
| export type SessionCreateInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutSessionInput | |
| } | |
| export type SessionUncheckedCreateInput = { | |
| id?: string | |
| userId: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutSessionNestedInput | |
| } | |
| export type SessionUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionCreateManyInput = { | |
| id?: string | |
| userId: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionListRelationFilter = { | |
| every?: Prisma.SessionWhereInput | |
| some?: Prisma.SessionWhereInput | |
| none?: Prisma.SessionWhereInput | |
| } | |
| export type SessionOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type SessionCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| } | |
| export type SessionUncheckedCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| } | |
| export type SessionUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| } | |
| export type SessionUncheckedUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| } | |
| export type NullableDateTimeFieldUpdateOperationsInput = { | |
| set?: Date | string | null | |
| } | |
| export type SessionCreateWithoutUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUncheckedCreateWithoutUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionCreateOrConnectWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | |
| } | |
| export type SessionCreateManyUserInputEnvelope = { | |
| data: Prisma.SessionCreateManyUserInput | Prisma.SessionCreateManyUserInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type SessionUpsertWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| update: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput> | |
| create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | |
| } | |
| export type SessionUpdateWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| data: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput> | |
| } | |
| export type SessionUpdateManyWithWhereWithoutUserInput = { | |
| where: Prisma.SessionScalarWhereInput | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyWithoutUserInput> | |
| } | |
| export type SessionScalarWhereInput = { | |
| AND?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| OR?: Prisma.SessionScalarWhereInput[] | |
| NOT?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Session"> | string | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| } | |
| export type SessionCreateManyUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateManyWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectScalar = { | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type SessionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "userId" | "createdAt" | "deletedAt", ExtArgs["result"]["session"]> | |
| export type SessionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type SessionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type SessionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type $SessionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Session" | |
| objects: { | |
| User: Prisma.$UserPayload<ExtArgs> | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| userId: string | |
| createdAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["session"]> | |
| composites: {} | |
| } | |
| export type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$SessionPayload, S> | |
| export type SessionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: SessionCountAggregateInputType | true | |
| } | |
| export interface SessionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } } | |
| /** | |
| * Find zero or one Session that matches the filter. | |
| * @param {SessionFindUniqueArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends SessionFindUniqueArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Session that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Session that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindFirstArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends SessionFindFirstArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Session that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Sessions that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Sessions | |
| * const sessions = await prisma.session.findMany() | |
| * | |
| * // Get first 10 Sessions | |
| * const sessions = await prisma.session.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends SessionFindManyArgs>(args?: Prisma.SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Session. | |
| * @param {SessionCreateArgs} args - Arguments to create a Session. | |
| * @example | |
| * // Create one Session | |
| * const Session = await prisma.session.create({ | |
| * data: { | |
| * // ... data to create a Session | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends SessionCreateArgs>(args: Prisma.SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Sessions. | |
| * @param {SessionCreateManyArgs} args - Arguments to create many Sessions. | |
| * @example | |
| * // Create many Sessions | |
| * const session = await prisma.session.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends SessionCreateManyArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Sessions and returns the data saved in the database. | |
| * @param {SessionCreateManyAndReturnArgs} args - Arguments to create many Sessions. | |
| * @example | |
| * // Create many Sessions | |
| * const session = await prisma.session.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Sessions and only return the `id` | |
| * const sessionWithIdOnly = await prisma.session.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends SessionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Session. | |
| * @param {SessionDeleteArgs} args - Arguments to delete one Session. | |
| * @example | |
| * // Delete one Session | |
| * const Session = await prisma.session.delete({ | |
| * where: { | |
| * // ... filter to delete one Session | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends SessionDeleteArgs>(args: Prisma.SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Session. | |
| * @param {SessionUpdateArgs} args - Arguments to update one Session. | |
| * @example | |
| * // Update one Session | |
| * const session = await prisma.session.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends SessionUpdateArgs>(args: Prisma.SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Sessions. | |
| * @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete. | |
| * @example | |
| * // Delete a few Sessions | |
| * const { count } = await prisma.session.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends SessionDeleteManyArgs>(args?: Prisma.SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Sessions. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Sessions | |
| * const session = await prisma.session.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends SessionUpdateManyArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Sessions and returns the data updated in the database. | |
| * @param {SessionUpdateManyAndReturnArgs} args - Arguments to update many Sessions. | |
| * @example | |
| * // Update many Sessions | |
| * const session = await prisma.session.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Sessions and only return the `id` | |
| * const sessionWithIdOnly = await prisma.session.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends SessionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Session. | |
| * @param {SessionUpsertArgs} args - Arguments to update or create a Session. | |
| * @example | |
| * // Update or create a Session | |
| * const session = await prisma.session.upsert({ | |
| * create: { | |
| * // ... data to create a Session | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Session we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends SessionUpsertArgs>(args: Prisma.SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Sessions. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionCountArgs} args - Arguments to filter Sessions to count. | |
| * @example | |
| * // Count the number of Sessions | |
| * const count = await prisma.session.count({ | |
| * where: { | |
| * // ... the filter for the Sessions we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends SessionCountArgs>( | |
| args?: Prisma.Subset<T, SessionCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], SessionCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Session. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends SessionAggregateArgs>(args: Prisma.Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>> | |
| /** | |
| * Group by Session. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends SessionGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: SessionGroupByArgs['orderBy'] } | |
| : { orderBy?: SessionGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Session model | |
| */ | |
| readonly fields: SessionFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Session. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__SessionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| User<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Session model | |
| */ | |
| export interface SessionFieldRefs { | |
| readonly id: Prisma.FieldRef<"Session", 'String'> | |
| readonly userId: Prisma.FieldRef<"Session", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"Session", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Session", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Session findUnique | |
| */ | |
| export type SessionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session findUniqueOrThrow | |
| */ | |
| export type SessionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session findFirst | |
| */ | |
| export type SessionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Sessions. | |
| */ | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session findFirstOrThrow | |
| */ | |
| export type SessionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Sessions. | |
| */ | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session findMany | |
| */ | |
| export type SessionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Sessions to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session create | |
| */ | |
| export type SessionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Session. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput> | |
| } | |
| /** | |
| * Session createMany | |
| */ | |
| export type SessionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Sessions. | |
| */ | |
| data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Session createManyAndReturn | |
| */ | |
| export type SessionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Sessions. | |
| */ | |
| data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Session update | |
| */ | |
| export type SessionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Session. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput> | |
| /** | |
| * Choose, which Session to update. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session updateMany | |
| */ | |
| export type SessionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Sessions. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Sessions to update | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Session updateManyAndReturn | |
| */ | |
| export type SessionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Sessions. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Sessions to update | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Session upsert | |
| */ | |
| export type SessionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Session to update in case it exists. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| /** | |
| * In case the Session found by the `where` argument doesn't exist, create a new Session with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput> | |
| /** | |
| * In case the Session was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput> | |
| } | |
| /** | |
| * Session delete | |
| */ | |
| export type SessionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter which Session to delete. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session deleteMany | |
| */ | |
| export type SessionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Sessions to delete | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Session without action | |
| */ | |
| export type SessionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/models/User.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `User` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type UserModel = runtime.Types.Result.DefaultSelection<Prisma.$UserPayload> | |
| export type AggregateUser = { | |
| _count: UserCountAggregateOutputType | null | |
| _min: UserMinAggregateOutputType | null | |
| _max: UserMaxAggregateOutputType | null | |
| } | |
| export type UserMinAggregateOutputType = { | |
| id: string | null | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| } | |
| export type UserMaxAggregateOutputType = { | |
| id: string | null | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| } | |
| export type UserCountAggregateOutputType = { | |
| id: number | |
| anonymousId: number | |
| telegramUserId: number | |
| telegramUserData: number | |
| isBlackTheme: number | |
| createdAt: number | |
| updatedAt: number | |
| _all: number | |
| } | |
| export type UserMinAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| } | |
| export type UserMaxAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| } | |
| export type UserCountAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| telegramUserData?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| _all?: true | |
| } | |
| export type UserAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which User to aggregate. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Users | |
| **/ | |
| _count?: true | UserCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: UserMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: UserMaxAggregateInputType | |
| } | |
| export type GetUserAggregateType<T extends UserAggregateArgs> = { | |
| [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateUser[P]> | |
| : Prisma.GetScalarType<T[P], AggregateUser[P]> | |
| } | |
| export type UserGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.UserWhereInput | |
| orderBy?: Prisma.UserOrderByWithAggregationInput | Prisma.UserOrderByWithAggregationInput[] | |
| by: Prisma.UserScalarFieldEnum[] | Prisma.UserScalarFieldEnum | |
| having?: Prisma.UserScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: UserCountAggregateInputType | true | |
| _min?: UserMinAggregateInputType | |
| _max?: UserMaxAggregateInputType | |
| } | |
| export type UserGroupByOutputType = { | |
| id: string | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| telegramUserData: runtime.JsonValue | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| _count: UserCountAggregateOutputType | null | |
| _min: UserMinAggregateOutputType | null | |
| _max: UserMaxAggregateOutputType | null | |
| } | |
| type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<UserGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type UserWhereInput = { | |
| AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| OR?: Prisma.UserWhereInput[] | |
| NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| id?: Prisma.UuidFilter<"User"> | string | |
| anonymousId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| Session?: Prisma.SessionListRelationFilter | |
| Dashboard?: Prisma.DashboardListRelationFilter | |
| } | |
| export type UserOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| Session?: Prisma.SessionOrderByRelationAggregateInput | |
| Dashboard?: Prisma.DashboardOrderByRelationAggregateInput | |
| } | |
| export type UserWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| telegramUserId?: string | |
| AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| OR?: Prisma.UserWhereInput[] | |
| NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| anonymousId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| Session?: Prisma.SessionListRelationFilter | |
| Dashboard?: Prisma.DashboardListRelationFilter | |
| }, "id" | "telegramUserId"> | |
| export type UserOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| _count?: Prisma.UserCountOrderByAggregateInput | |
| _max?: Prisma.UserMaxOrderByAggregateInput | |
| _min?: Prisma.UserMinOrderByAggregateInput | |
| } | |
| export type UserScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.UserScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"User"> | string | |
| anonymousId?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null | |
| telegramUserId?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableWithAggregatesFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string | |
| } | |
| export type UserCreateInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionCreateNestedManyWithoutUserInput | |
| Dashboard?: Prisma.DashboardCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput | |
| Dashboard?: Prisma.DashboardUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUpdateManyWithoutUserNestedInput | |
| Dashboard?: Prisma.DashboardUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput | |
| Dashboard?: Prisma.DashboardUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserCreateManyInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| } | |
| export type UserUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| } | |
| export type UserUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| } | |
| export type UserCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserScalarRelationFilter = { | |
| is?: Prisma.UserWhereInput | |
| isNot?: Prisma.UserWhereInput | |
| } | |
| export type StringFieldUpdateOperationsInput = { | |
| set?: string | |
| } | |
| export type NullableStringFieldUpdateOperationsInput = { | |
| set?: string | null | |
| } | |
| export type NullableBoolFieldUpdateOperationsInput = { | |
| set?: boolean | null | |
| } | |
| export type DateTimeFieldUpdateOperationsInput = { | |
| set?: Date | string | |
| } | |
| export type UserCreateNestedOneWithoutSessionInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| } | |
| export type UserUpdateOneRequiredWithoutSessionNestedInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionInput | |
| upsert?: Prisma.UserUpsertWithoutSessionInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutSessionInput, Prisma.UserUpdateWithoutSessionInput>, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| } | |
| export type UserCreateNestedOneWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutDashboardInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| } | |
| export type UserUpdateOneRequiredWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutDashboardInput | |
| upsert?: Prisma.UserUpsertWithoutDashboardInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutDashboardInput, Prisma.UserUpdateWithoutDashboardInput>, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type UserCreateWithoutSessionInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Dashboard?: Prisma.DashboardCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateWithoutSessionInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Dashboard?: Prisma.DashboardUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserCreateOrConnectWithoutSessionInput = { | |
| where: Prisma.UserWhereUniqueInput | |
| create: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| } | |
| export type UserUpsertWithoutSessionInput = { | |
| update: Prisma.XOR<Prisma.UserUpdateWithoutSessionInput, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| create: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| where?: Prisma.UserWhereInput | |
| } | |
| export type UserUpdateToOneWithWhereWithoutSessionInput = { | |
| where?: Prisma.UserWhereInput | |
| data: Prisma.XOR<Prisma.UserUpdateWithoutSessionInput, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| } | |
| export type UserUpdateWithoutSessionInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Dashboard?: Prisma.DashboardUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateWithoutSessionInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Dashboard?: Prisma.DashboardUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserCreateWithoutDashboardInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateWithoutDashboardInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserCreateOrConnectWithoutDashboardInput = { | |
| where: Prisma.UserWhereUniqueInput | |
| create: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type UserUpsertWithoutDashboardInput = { | |
| update: Prisma.XOR<Prisma.UserUpdateWithoutDashboardInput, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| create: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| where?: Prisma.UserWhereInput | |
| } | |
| export type UserUpdateToOneWithWhereWithoutDashboardInput = { | |
| where?: Prisma.UserWhereInput | |
| data: Prisma.XOR<Prisma.UserUpdateWithoutDashboardInput, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type UserUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| /** | |
| * Count Type UserCountOutputType | |
| */ | |
| export type UserCountOutputType = { | |
| Session: number | |
| Dashboard: number | |
| } | |
| export type UserCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Session?: boolean | UserCountOutputTypeCountSessionArgs | |
| Dashboard?: boolean | UserCountOutputTypeCountDashboardArgs | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the UserCountOutputType | |
| */ | |
| select?: Prisma.UserCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeCountSessionArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.SessionWhereInput | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeCountDashboardArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.DashboardWhereInput | |
| } | |
| export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| Session?: boolean | Prisma.User$SessionArgs<ExtArgs> | |
| Dashboard?: boolean | Prisma.User$DashboardArgs<ExtArgs> | |
| _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectScalar = { | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| } | |
| export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "anonymousId" | "telegramUserId" | "telegramUserData" | "isBlackTheme" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]> | |
| export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Session?: boolean | Prisma.User$SessionArgs<ExtArgs> | |
| Dashboard?: boolean | Prisma.User$DashboardArgs<ExtArgs> | |
| _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type UserIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {} | |
| export type UserIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {} | |
| export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "User" | |
| objects: { | |
| Session: Prisma.$SessionPayload<ExtArgs>[] | |
| Dashboard: Prisma.$DashboardPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| telegramUserData: runtime.JsonValue | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| }, ExtArgs["result"]["user"]> | |
| composites: {} | |
| } | |
| export type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$UserPayload, S> | |
| export type UserCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: UserCountAggregateInputType | true | |
| } | |
| export interface UserDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } } | |
| /** | |
| * Find zero or one User that matches the filter. | |
| * @param {UserFindUniqueArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends UserFindUniqueArgs>(args: Prisma.SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one User that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first User that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindFirstArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends UserFindFirstArgs>(args?: Prisma.SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first User that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Users that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Users | |
| * const users = await prisma.user.findMany() | |
| * | |
| * // Get first 10 Users | |
| * const users = await prisma.user.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends UserFindManyArgs>(args?: Prisma.SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a User. | |
| * @param {UserCreateArgs} args - Arguments to create a User. | |
| * @example | |
| * // Create one User | |
| * const User = await prisma.user.create({ | |
| * data: { | |
| * // ... data to create a User | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends UserCreateArgs>(args: Prisma.SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Users. | |
| * @param {UserCreateManyArgs} args - Arguments to create many Users. | |
| * @example | |
| * // Create many Users | |
| * const user = await prisma.user.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends UserCreateManyArgs>(args?: Prisma.SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Users and returns the data saved in the database. | |
| * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users. | |
| * @example | |
| * // Create many Users | |
| * const user = await prisma.user.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Users and only return the `id` | |
| * const userWithIdOnly = await prisma.user.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a User. | |
| * @param {UserDeleteArgs} args - Arguments to delete one User. | |
| * @example | |
| * // Delete one User | |
| * const User = await prisma.user.delete({ | |
| * where: { | |
| * // ... filter to delete one User | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends UserDeleteArgs>(args: Prisma.SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one User. | |
| * @param {UserUpdateArgs} args - Arguments to update one User. | |
| * @example | |
| * // Update one User | |
| * const user = await prisma.user.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends UserUpdateArgs>(args: Prisma.SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Users. | |
| * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete. | |
| * @example | |
| * // Delete a few Users | |
| * const { count } = await prisma.user.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends UserDeleteManyArgs>(args?: Prisma.SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Users. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Users | |
| * const user = await prisma.user.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends UserUpdateManyArgs>(args: Prisma.SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Users and returns the data updated in the database. | |
| * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users. | |
| * @example | |
| * // Update many Users | |
| * const user = await prisma.user.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Users and only return the `id` | |
| * const userWithIdOnly = await prisma.user.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one User. | |
| * @param {UserUpsertArgs} args - Arguments to update or create a User. | |
| * @example | |
| * // Update or create a User | |
| * const user = await prisma.user.upsert({ | |
| * create: { | |
| * // ... data to create a User | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the User we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends UserUpsertArgs>(args: Prisma.SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Users. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserCountArgs} args - Arguments to filter Users to count. | |
| * @example | |
| * // Count the number of Users | |
| * const count = await prisma.user.count({ | |
| * where: { | |
| * // ... the filter for the Users we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends UserCountArgs>( | |
| args?: Prisma.Subset<T, UserCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], UserCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a User. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends UserAggregateArgs>(args: Prisma.Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>> | |
| /** | |
| * Group by User. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends UserGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: UserGroupByArgs['orderBy'] } | |
| : { orderBy?: UserGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the User model | |
| */ | |
| readonly fields: UserFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for User. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__UserClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Session<T extends Prisma.User$SessionArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$SessionArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| Dashboard<T extends Prisma.User$DashboardArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$DashboardArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the User model | |
| */ | |
| export interface UserFieldRefs { | |
| readonly id: Prisma.FieldRef<"User", 'String'> | |
| readonly anonymousId: Prisma.FieldRef<"User", 'String'> | |
| readonly telegramUserId: Prisma.FieldRef<"User", 'String'> | |
| readonly telegramUserData: Prisma.FieldRef<"User", 'Json'> | |
| readonly isBlackTheme: Prisma.FieldRef<"User", 'Boolean'> | |
| readonly createdAt: Prisma.FieldRef<"User", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"User", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * User findUnique | |
| */ | |
| export type UserFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User findUniqueOrThrow | |
| */ | |
| export type UserFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User findFirst | |
| */ | |
| export type UserFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Users. | |
| */ | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User findFirstOrThrow | |
| */ | |
| export type UserFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Users. | |
| */ | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User findMany | |
| */ | |
| export type UserFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Users to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User create | |
| */ | |
| export type UserCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a User. | |
| */ | |
| data?: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput> | |
| } | |
| /** | |
| * User createMany | |
| */ | |
| export type UserCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Users. | |
| */ | |
| data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * User createManyAndReturn | |
| */ | |
| export type UserCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Users. | |
| */ | |
| data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * User update | |
| */ | |
| export type UserUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a User. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput> | |
| /** | |
| * Choose, which User to update. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User updateMany | |
| */ | |
| export type UserUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Users. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Users to update | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User updateManyAndReturn | |
| */ | |
| export type UserUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Users. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Users to update | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User upsert | |
| */ | |
| export type UserUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the User to update in case it exists. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| /** | |
| * In case the User found by the `where` argument doesn't exist, create a new User with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput> | |
| /** | |
| * In case the User was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput> | |
| } | |
| /** | |
| * User delete | |
| */ | |
| export type UserDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter which User to delete. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User deleteMany | |
| */ | |
| export type UserDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Users to delete | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User.Session | |
| */ | |
| export type User$SessionArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| where?: Prisma.SessionWhereInput | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * User.Dashboard | |
| */ | |
| export type User$DashboardArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| where?: Prisma.DashboardWhereInput | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * User without action | |
| */ | |
| export type UserDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/models/Widget.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Widget` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type WidgetModel = runtime.Types.Result.DefaultSelection<Prisma.$WidgetPayload> | |
| export type AggregateWidget = { | |
| _count: WidgetCountAggregateOutputType | null | |
| _avg: WidgetAvgAggregateOutputType | null | |
| _sum: WidgetSumAggregateOutputType | null | |
| _min: WidgetMinAggregateOutputType | null | |
| _max: WidgetMaxAggregateOutputType | null | |
| } | |
| export type WidgetAvgAggregateOutputType = { | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| } | |
| export type WidgetSumAggregateOutputType = { | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| } | |
| export type WidgetMinAggregateOutputType = { | |
| id: string | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetMaxAggregateOutputType = { | |
| id: string | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetCountAggregateOutputType = { | |
| id: number | |
| options: number | |
| state: number | |
| columnIndex: number | |
| rowIndex: number | |
| columnCount: number | |
| rowCount: number | |
| isBlackTheme: number | |
| backgroundColor: number | |
| primaryColor: number | |
| positiveColor: number | |
| negativeColor: number | |
| dashboardId: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type WidgetAvgAggregateInputType = { | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| } | |
| export type WidgetSumAggregateInputType = { | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| } | |
| export type WidgetMinAggregateInputType = { | |
| id?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetMaxAggregateInputType = { | |
| id?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetCountAggregateInputType = { | |
| id?: true | |
| options?: true | |
| state?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type WidgetAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Widget to aggregate. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Widgets | |
| **/ | |
| _count?: true | WidgetCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to average | |
| **/ | |
| _avg?: WidgetAvgAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to sum | |
| **/ | |
| _sum?: WidgetSumAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: WidgetMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: WidgetMaxAggregateInputType | |
| } | |
| export type GetWidgetAggregateType<T extends WidgetAggregateArgs> = { | |
| [P in keyof T & keyof AggregateWidget]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateWidget[P]> | |
| : Prisma.GetScalarType<T[P], AggregateWidget[P]> | |
| } | |
| export type WidgetGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetWhereInput | |
| orderBy?: Prisma.WidgetOrderByWithAggregationInput | Prisma.WidgetOrderByWithAggregationInput[] | |
| by: Prisma.WidgetScalarFieldEnum[] | Prisma.WidgetScalarFieldEnum | |
| having?: Prisma.WidgetScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: WidgetCountAggregateInputType | true | |
| _avg?: WidgetAvgAggregateInputType | |
| _sum?: WidgetSumAggregateInputType | |
| _min?: WidgetMinAggregateInputType | |
| _max?: WidgetMaxAggregateInputType | |
| } | |
| export type WidgetGroupByOutputType = { | |
| id: string | |
| options: runtime.JsonValue | null | |
| state: runtime.JsonValue | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: WidgetCountAggregateOutputType | null | |
| _avg: WidgetAvgAggregateOutputType | null | |
| _sum: WidgetSumAggregateOutputType | null | |
| _min: WidgetMinAggregateOutputType | null | |
| _max: WidgetMaxAggregateOutputType | null | |
| } | |
| type GetWidgetGroupByPayload<T extends WidgetGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<WidgetGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof WidgetGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], WidgetGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], WidgetGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type WidgetWhereInput = { | |
| AND?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| OR?: Prisma.WidgetWhereInput[] | |
| NOT?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| id?: Prisma.UuidFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| Dashboard?: Prisma.XOR<Prisma.DashboardScalarRelationFilter, Prisma.DashboardWhereInput> | |
| WidgetLog?: Prisma.WidgetLogListRelationFilter | |
| } | |
| export type WidgetOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrderInput | Prisma.SortOrder | |
| state?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| Dashboard?: Prisma.DashboardOrderByWithRelationInput | |
| WidgetLog?: Prisma.WidgetLogOrderByRelationAggregateInput | |
| } | |
| export type WidgetWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| OR?: Prisma.WidgetWhereInput[] | |
| NOT?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| Dashboard?: Prisma.XOR<Prisma.DashboardScalarRelationFilter, Prisma.DashboardWhereInput> | |
| WidgetLog?: Prisma.WidgetLogListRelationFilter | |
| }, "id"> | |
| export type WidgetOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrderInput | Prisma.SortOrder | |
| state?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.WidgetCountOrderByAggregateInput | |
| _avg?: Prisma.WidgetAvgOrderByAggregateInput | |
| _max?: Prisma.WidgetMaxOrderByAggregateInput | |
| _min?: Prisma.WidgetMinOrderByAggregateInput | |
| _sum?: Prisma.WidgetSumOrderByAggregateInput | |
| } | |
| export type WidgetScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.WidgetScalarWhereWithAggregatesInput | Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.WidgetScalarWhereWithAggregatesInput | Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableWithAggregatesFilter<"Widget"> | |
| state?: Prisma.JsonNullableWithAggregatesFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidWithAggregatesFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Widget"> | Date | string | null | |
| } | |
| export type WidgetCreateInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Dashboard: Prisma.DashboardCreateNestedOneWithoutWidgetInput | |
| WidgetLog?: Prisma.WidgetLogCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Dashboard?: Prisma.DashboardUpdateOneRequiredWithoutWidgetNestedInput | |
| WidgetLog?: Prisma.WidgetLogUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetCreateManyInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetListRelationFilter = { | |
| every?: Prisma.WidgetWhereInput | |
| some?: Prisma.WidgetWhereInput | |
| none?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type WidgetCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrder | |
| state?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetAvgOrderByAggregateInput = { | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| } | |
| export type WidgetMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetSumOrderByAggregateInput = { | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| } | |
| export type WidgetScalarRelationFilter = { | |
| is?: Prisma.WidgetWhereInput | |
| isNot?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetCreateNestedManyWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| } | |
| export type WidgetUncheckedCreateNestedManyWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| } | |
| export type WidgetUpdateManyWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| upsert?: Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| set?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| delete?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| update?: Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput[] | |
| updateMany?: Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput | Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput[] | |
| deleteMany?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| } | |
| export type WidgetUncheckedUpdateManyWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| upsert?: Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| set?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| delete?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| update?: Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput[] | |
| updateMany?: Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput | Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput[] | |
| deleteMany?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| } | |
| export type NullableIntFieldUpdateOperationsInput = { | |
| set?: number | null | |
| increment?: number | |
| decrement?: number | |
| multiply?: number | |
| divide?: number | |
| } | |
| export type WidgetCreateNestedOneWithoutWidgetLogInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutWidgetLogInput | |
| connect?: Prisma.WidgetWhereUniqueInput | |
| } | |
| export type WidgetUpdateOneRequiredWithoutWidgetLogNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutWidgetLogInput | |
| upsert?: Prisma.WidgetUpsertWithoutWidgetLogInput | |
| connect?: Prisma.WidgetWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.WidgetUpdateToOneWithWhereWithoutWidgetLogInput, Prisma.WidgetUpdateWithoutWidgetLogInput>, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| } | |
| export type WidgetCreateWithoutDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateWithoutDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetCreateOrConnectWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type WidgetCreateManyDashboardInputEnvelope = { | |
| data: Prisma.WidgetCreateManyDashboardInput | Prisma.WidgetCreateManyDashboardInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type WidgetUpsertWithWhereUniqueWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| update: Prisma.XOR<Prisma.WidgetUpdateWithoutDashboardInput, Prisma.WidgetUncheckedUpdateWithoutDashboardInput> | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type WidgetUpdateWithWhereUniqueWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateWithoutDashboardInput, Prisma.WidgetUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type WidgetUpdateManyWithWhereWithoutDashboardInput = { | |
| where: Prisma.WidgetScalarWhereInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyWithoutDashboardInput> | |
| } | |
| export type WidgetScalarWhereInput = { | |
| AND?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| OR?: Prisma.WidgetScalarWhereInput[] | |
| NOT?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| } | |
| export type WidgetCreateWithoutWidgetLogInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Dashboard: Prisma.DashboardCreateNestedOneWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateWithoutWidgetLogInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetCreateOrConnectWithoutWidgetLogInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| } | |
| export type WidgetUpsertWithoutWidgetLogInput = { | |
| update: Prisma.XOR<Prisma.WidgetUpdateWithoutWidgetLogInput, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| where?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetUpdateToOneWithWhereWithoutWidgetLogInput = { | |
| where?: Prisma.WidgetWhereInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateWithoutWidgetLogInput, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| } | |
| export type WidgetUpdateWithoutWidgetLogInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Dashboard?: Prisma.DashboardUpdateOneRequiredWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateWithoutWidgetLogInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetCreateManyDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateManyWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| /** | |
| * Count Type WidgetCountOutputType | |
| */ | |
| export type WidgetCountOutputType = { | |
| WidgetLog: number | |
| } | |
| export type WidgetCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| WidgetLog?: boolean | WidgetCountOutputTypeCountWidgetLogArgs | |
| } | |
| /** | |
| * WidgetCountOutputType without action | |
| */ | |
| export type WidgetCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetCountOutputType | |
| */ | |
| select?: Prisma.WidgetCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetCountOutputType without action | |
| */ | |
| export type WidgetCountOutputTypeCountWidgetLogArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetLogWhereInput | |
| } | |
| export type WidgetSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| WidgetLog?: boolean | Prisma.Widget$WidgetLogArgs<ExtArgs> | |
| _count?: boolean | Prisma.WidgetCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectScalar = { | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type WidgetOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "options" | "state" | "columnIndex" | "rowIndex" | "columnCount" | "rowCount" | "isBlackTheme" | "backgroundColor" | "primaryColor" | "positiveColor" | "negativeColor" | "dashboardId" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["widget"]> | |
| export type WidgetInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| WidgetLog?: boolean | Prisma.Widget$WidgetLogArgs<ExtArgs> | |
| _count?: boolean | Prisma.WidgetCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| } | |
| export type $WidgetPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Widget" | |
| objects: { | |
| Dashboard: Prisma.$DashboardPayload<ExtArgs> | |
| WidgetLog: Prisma.$WidgetLogPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| options: runtime.JsonValue | null | |
| state: runtime.JsonValue | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["widget"]> | |
| composites: {} | |
| } | |
| export type WidgetGetPayload<S extends boolean | null | undefined | WidgetDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$WidgetPayload, S> | |
| export type WidgetCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<WidgetFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: WidgetCountAggregateInputType | true | |
| } | |
| export interface WidgetDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Widget'], meta: { name: 'Widget' } } | |
| /** | |
| * Find zero or one Widget that matches the filter. | |
| * @param {WidgetFindUniqueArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends WidgetFindUniqueArgs>(args: Prisma.SelectSubset<T, WidgetFindUniqueArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Widget that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {WidgetFindUniqueOrThrowArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends WidgetFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, WidgetFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Widget that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindFirstArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends WidgetFindFirstArgs>(args?: Prisma.SelectSubset<T, WidgetFindFirstArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Widget that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindFirstOrThrowArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends WidgetFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, WidgetFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Widgets that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Widgets | |
| * const widgets = await prisma.widget.findMany() | |
| * | |
| * // Get first 10 Widgets | |
| * const widgets = await prisma.widget.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const widgetWithIdOnly = await prisma.widget.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends WidgetFindManyArgs>(args?: Prisma.SelectSubset<T, WidgetFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Widget. | |
| * @param {WidgetCreateArgs} args - Arguments to create a Widget. | |
| * @example | |
| * // Create one Widget | |
| * const Widget = await prisma.widget.create({ | |
| * data: { | |
| * // ... data to create a Widget | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends WidgetCreateArgs>(args: Prisma.SelectSubset<T, WidgetCreateArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Widgets. | |
| * @param {WidgetCreateManyArgs} args - Arguments to create many Widgets. | |
| * @example | |
| * // Create many Widgets | |
| * const widget = await prisma.widget.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends WidgetCreateManyArgs>(args?: Prisma.SelectSubset<T, WidgetCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Widgets and returns the data saved in the database. | |
| * @param {WidgetCreateManyAndReturnArgs} args - Arguments to create many Widgets. | |
| * @example | |
| * // Create many Widgets | |
| * const widget = await prisma.widget.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Widgets and only return the `id` | |
| * const widgetWithIdOnly = await prisma.widget.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends WidgetCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, WidgetCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Widget. | |
| * @param {WidgetDeleteArgs} args - Arguments to delete one Widget. | |
| * @example | |
| * // Delete one Widget | |
| * const Widget = await prisma.widget.delete({ | |
| * where: { | |
| * // ... filter to delete one Widget | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends WidgetDeleteArgs>(args: Prisma.SelectSubset<T, WidgetDeleteArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Widget. | |
| * @param {WidgetUpdateArgs} args - Arguments to update one Widget. | |
| * @example | |
| * // Update one Widget | |
| * const widget = await prisma.widget.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends WidgetUpdateArgs>(args: Prisma.SelectSubset<T, WidgetUpdateArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Widgets. | |
| * @param {WidgetDeleteManyArgs} args - Arguments to filter Widgets to delete. | |
| * @example | |
| * // Delete a few Widgets | |
| * const { count } = await prisma.widget.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends WidgetDeleteManyArgs>(args?: Prisma.SelectSubset<T, WidgetDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Widgets. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Widgets | |
| * const widget = await prisma.widget.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends WidgetUpdateManyArgs>(args: Prisma.SelectSubset<T, WidgetUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Widgets and returns the data updated in the database. | |
| * @param {WidgetUpdateManyAndReturnArgs} args - Arguments to update many Widgets. | |
| * @example | |
| * // Update many Widgets | |
| * const widget = await prisma.widget.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Widgets and only return the `id` | |
| * const widgetWithIdOnly = await prisma.widget.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends WidgetUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, WidgetUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Widget. | |
| * @param {WidgetUpsertArgs} args - Arguments to update or create a Widget. | |
| * @example | |
| * // Update or create a Widget | |
| * const widget = await prisma.widget.upsert({ | |
| * create: { | |
| * // ... data to create a Widget | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Widget we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends WidgetUpsertArgs>(args: Prisma.SelectSubset<T, WidgetUpsertArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Widgets. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetCountArgs} args - Arguments to filter Widgets to count. | |
| * @example | |
| * // Count the number of Widgets | |
| * const count = await prisma.widget.count({ | |
| * where: { | |
| * // ... the filter for the Widgets we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends WidgetCountArgs>( | |
| args?: Prisma.Subset<T, WidgetCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], WidgetCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Widget. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends WidgetAggregateArgs>(args: Prisma.Subset<T, WidgetAggregateArgs>): Prisma.PrismaPromise<GetWidgetAggregateType<T>> | |
| /** | |
| * Group by Widget. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends WidgetGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: WidgetGroupByArgs['orderBy'] } | |
| : { orderBy?: WidgetGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, WidgetGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWidgetGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Widget model | |
| */ | |
| readonly fields: WidgetFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Widget. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__WidgetClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Dashboard<T extends Prisma.DashboardDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.DashboardDefaultArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| WidgetLog<T extends Prisma.Widget$WidgetLogArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Widget$WidgetLogArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Widget model | |
| */ | |
| export interface WidgetFieldRefs { | |
| readonly id: Prisma.FieldRef<"Widget", 'String'> | |
| readonly options: Prisma.FieldRef<"Widget", 'Json'> | |
| readonly state: Prisma.FieldRef<"Widget", 'Json'> | |
| readonly columnIndex: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly rowIndex: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly columnCount: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly rowCount: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly isBlackTheme: Prisma.FieldRef<"Widget", 'Boolean'> | |
| readonly backgroundColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly primaryColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly positiveColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly negativeColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly dashboardId: Prisma.FieldRef<"Widget", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Widget findUnique | |
| */ | |
| export type WidgetFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget findUniqueOrThrow | |
| */ | |
| export type WidgetFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget findFirst | |
| */ | |
| export type WidgetFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Widgets. | |
| */ | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget findFirstOrThrow | |
| */ | |
| export type WidgetFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Widgets. | |
| */ | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget findMany | |
| */ | |
| export type WidgetFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widgets to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget create | |
| */ | |
| export type WidgetCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Widget. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetCreateInput, Prisma.WidgetUncheckedCreateInput> | |
| } | |
| /** | |
| * Widget createMany | |
| */ | |
| export type WidgetCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Widgets. | |
| */ | |
| data: Prisma.WidgetCreateManyInput | Prisma.WidgetCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Widget createManyAndReturn | |
| */ | |
| export type WidgetCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Widgets. | |
| */ | |
| data: Prisma.WidgetCreateManyInput | Prisma.WidgetCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Widget update | |
| */ | |
| export type WidgetUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Widget. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateInput, Prisma.WidgetUncheckedUpdateInput> | |
| /** | |
| * Choose, which Widget to update. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget updateMany | |
| */ | |
| export type WidgetUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Widgets. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Widgets to update | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Widget updateManyAndReturn | |
| */ | |
| export type WidgetUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Widgets. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Widgets to update | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Widget upsert | |
| */ | |
| export type WidgetUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Widget to update in case it exists. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * In case the Widget found by the `where` argument doesn't exist, create a new Widget with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.WidgetCreateInput, Prisma.WidgetUncheckedCreateInput> | |
| /** | |
| * In case the Widget was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.WidgetUpdateInput, Prisma.WidgetUncheckedUpdateInput> | |
| } | |
| /** | |
| * Widget delete | |
| */ | |
| export type WidgetDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter which Widget to delete. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget deleteMany | |
| */ | |
| export type WidgetDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Widgets to delete | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Widget.WidgetLog | |
| */ | |
| export type Widget$WidgetLogArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| where?: Prisma.WidgetLogWhereInput | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget without action | |
| */ | |
| export type WidgetDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/models/WidgetLog.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `WidgetLog` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLogModel = runtime.Types.Result.DefaultSelection<Prisma.$WidgetLogPayload> | |
| export type AggregateWidgetLog = { | |
| _count: WidgetLogCountAggregateOutputType | null | |
| _min: WidgetLogMinAggregateOutputType | null | |
| _max: WidgetLogMaxAggregateOutputType | null | |
| } | |
| export type WidgetLogMinAggregateOutputType = { | |
| id: string | null | |
| widgetId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetLogMaxAggregateOutputType = { | |
| id: string | null | |
| widgetId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetLogCountAggregateOutputType = { | |
| id: number | |
| oldOptions: number | |
| newOptions: number | |
| oldState: number | |
| newState: number | |
| widgetId: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type WidgetLogMinAggregateInputType = { | |
| id?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetLogMaxAggregateInputType = { | |
| id?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetLogCountAggregateInputType = { | |
| id?: true | |
| oldOptions?: true | |
| newOptions?: true | |
| oldState?: true | |
| newState?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type WidgetLogAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which WidgetLog to aggregate. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned WidgetLogs | |
| **/ | |
| _count?: true | WidgetLogCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: WidgetLogMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: WidgetLogMaxAggregateInputType | |
| } | |
| export type GetWidgetLogAggregateType<T extends WidgetLogAggregateArgs> = { | |
| [P in keyof T & keyof AggregateWidgetLog]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateWidgetLog[P]> | |
| : Prisma.GetScalarType<T[P], AggregateWidgetLog[P]> | |
| } | |
| export type WidgetLogGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetLogWhereInput | |
| orderBy?: Prisma.WidgetLogOrderByWithAggregationInput | Prisma.WidgetLogOrderByWithAggregationInput[] | |
| by: Prisma.WidgetLogScalarFieldEnum[] | Prisma.WidgetLogScalarFieldEnum | |
| having?: Prisma.WidgetLogScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: WidgetLogCountAggregateInputType | true | |
| _min?: WidgetLogMinAggregateInputType | |
| _max?: WidgetLogMaxAggregateInputType | |
| } | |
| export type WidgetLogGroupByOutputType = { | |
| id: string | |
| oldOptions: runtime.JsonValue | null | |
| newOptions: runtime.JsonValue | null | |
| oldState: runtime.JsonValue | null | |
| newState: runtime.JsonValue | null | |
| widgetId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: WidgetLogCountAggregateOutputType | null | |
| _min: WidgetLogMinAggregateOutputType | null | |
| _max: WidgetLogMaxAggregateOutputType | null | |
| } | |
| type GetWidgetLogGroupByPayload<T extends WidgetLogGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<WidgetLogGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof WidgetLogGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], WidgetLogGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], WidgetLogGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type WidgetLogWhereInput = { | |
| AND?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| OR?: Prisma.WidgetLogWhereInput[] | |
| NOT?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| id?: Prisma.UuidFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| Widget?: Prisma.XOR<Prisma.WidgetScalarRelationFilter, Prisma.WidgetWhereInput> | |
| } | |
| export type WidgetLogOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| oldState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| Widget?: Prisma.WidgetOrderByWithRelationInput | |
| } | |
| export type WidgetLogWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| OR?: Prisma.WidgetLogWhereInput[] | |
| NOT?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| Widget?: Prisma.XOR<Prisma.WidgetScalarRelationFilter, Prisma.WidgetWhereInput> | |
| }, "id"> | |
| export type WidgetLogOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| oldState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.WidgetLogCountOrderByAggregateInput | |
| _max?: Prisma.WidgetLogMaxOrderByAggregateInput | |
| _min?: Prisma.WidgetLogMinOrderByAggregateInput | |
| } | |
| export type WidgetLogScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.WidgetLogScalarWhereWithAggregatesInput | Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.WidgetLogScalarWhereWithAggregatesInput | Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidWithAggregatesFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"WidgetLog"> | Date | string | null | |
| } | |
| export type WidgetLogCreateInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget: Prisma.WidgetCreateNestedOneWithoutWidgetLogInput | |
| } | |
| export type WidgetLogUncheckedCreateInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUpdateOneRequiredWithoutWidgetLogNestedInput | |
| } | |
| export type WidgetLogUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogCreateManyInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogListRelationFilter = { | |
| every?: Prisma.WidgetLogWhereInput | |
| some?: Prisma.WidgetLogWhereInput | |
| none?: Prisma.WidgetLogWhereInput | |
| } | |
| export type WidgetLogOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type WidgetLogCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrder | |
| newOptions?: Prisma.SortOrder | |
| oldState?: Prisma.SortOrder | |
| newState?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogCreateNestedManyWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| } | |
| export type WidgetLogUncheckedCreateNestedManyWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| } | |
| export type WidgetLogUpdateManyWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| upsert?: Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| set?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| delete?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| update?: Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput[] | |
| updateMany?: Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput | Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput[] | |
| deleteMany?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| } | |
| export type WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| upsert?: Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| set?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| delete?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| update?: Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput[] | |
| updateMany?: Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput | Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput[] | |
| deleteMany?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| } | |
| export type WidgetLogCreateWithoutWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUncheckedCreateWithoutWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogCreateOrConnectWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type WidgetLogCreateManyWidgetInputEnvelope = { | |
| data: Prisma.WidgetLogCreateManyWidgetInput | Prisma.WidgetLogCreateManyWidgetInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type WidgetLogUpsertWithWhereUniqueWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| update: Prisma.XOR<Prisma.WidgetLogUpdateWithoutWidgetInput, Prisma.WidgetLogUncheckedUpdateWithoutWidgetInput> | |
| create: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type WidgetLogUpdateWithWhereUniqueWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateWithoutWidgetInput, Prisma.WidgetLogUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type WidgetLogUpdateManyWithWhereWithoutWidgetInput = { | |
| where: Prisma.WidgetLogScalarWhereInput | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetInput> | |
| } | |
| export type WidgetLogScalarWhereInput = { | |
| AND?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| OR?: Prisma.WidgetLogScalarWhereInput[] | |
| NOT?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| } | |
| export type WidgetLogCreateManyWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateManyWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectScalar = { | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type WidgetLogOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "oldOptions" | "newOptions" | "oldState" | "newState" | "widgetId" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetLogIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetLogIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type $WidgetLogPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "WidgetLog" | |
| objects: { | |
| Widget: Prisma.$WidgetPayload<ExtArgs> | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| oldOptions: runtime.JsonValue | null | |
| newOptions: runtime.JsonValue | null | |
| oldState: runtime.JsonValue | null | |
| newState: runtime.JsonValue | null | |
| widgetId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["widgetLog"]> | |
| composites: {} | |
| } | |
| export type WidgetLogGetPayload<S extends boolean | null | undefined | WidgetLogDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload, S> | |
| export type WidgetLogCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<WidgetLogFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: WidgetLogCountAggregateInputType | true | |
| } | |
| export interface WidgetLogDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['WidgetLog'], meta: { name: 'WidgetLog' } } | |
| /** | |
| * Find zero or one WidgetLog that matches the filter. | |
| * @param {WidgetLogFindUniqueArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends WidgetLogFindUniqueArgs>(args: Prisma.SelectSubset<T, WidgetLogFindUniqueArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one WidgetLog that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {WidgetLogFindUniqueOrThrowArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends WidgetLogFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, WidgetLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first WidgetLog that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindFirstArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends WidgetLogFindFirstArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindFirstArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first WidgetLog that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindFirstOrThrowArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends WidgetLogFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more WidgetLogs that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany() | |
| * | |
| * // Get first 10 WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends WidgetLogFindManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a WidgetLog. | |
| * @param {WidgetLogCreateArgs} args - Arguments to create a WidgetLog. | |
| * @example | |
| * // Create one WidgetLog | |
| * const WidgetLog = await prisma.widgetLog.create({ | |
| * data: { | |
| * // ... data to create a WidgetLog | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends WidgetLogCreateArgs>(args: Prisma.SelectSubset<T, WidgetLogCreateArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many WidgetLogs. | |
| * @param {WidgetLogCreateManyArgs} args - Arguments to create many WidgetLogs. | |
| * @example | |
| * // Create many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends WidgetLogCreateManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many WidgetLogs and returns the data saved in the database. | |
| * @param {WidgetLogCreateManyAndReturnArgs} args - Arguments to create many WidgetLogs. | |
| * @example | |
| * // Create many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many WidgetLogs and only return the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends WidgetLogCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, WidgetLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a WidgetLog. | |
| * @param {WidgetLogDeleteArgs} args - Arguments to delete one WidgetLog. | |
| * @example | |
| * // Delete one WidgetLog | |
| * const WidgetLog = await prisma.widgetLog.delete({ | |
| * where: { | |
| * // ... filter to delete one WidgetLog | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends WidgetLogDeleteArgs>(args: Prisma.SelectSubset<T, WidgetLogDeleteArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one WidgetLog. | |
| * @param {WidgetLogUpdateArgs} args - Arguments to update one WidgetLog. | |
| * @example | |
| * // Update one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends WidgetLogUpdateArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more WidgetLogs. | |
| * @param {WidgetLogDeleteManyArgs} args - Arguments to filter WidgetLogs to delete. | |
| * @example | |
| * // Delete a few WidgetLogs | |
| * const { count } = await prisma.widgetLog.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends WidgetLogDeleteManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more WidgetLogs. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends WidgetLogUpdateManyArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more WidgetLogs and returns the data updated in the database. | |
| * @param {WidgetLogUpdateManyAndReturnArgs} args - Arguments to update many WidgetLogs. | |
| * @example | |
| * // Update many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more WidgetLogs and only return the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends WidgetLogUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one WidgetLog. | |
| * @param {WidgetLogUpsertArgs} args - Arguments to update or create a WidgetLog. | |
| * @example | |
| * // Update or create a WidgetLog | |
| * const widgetLog = await prisma.widgetLog.upsert({ | |
| * create: { | |
| * // ... data to create a WidgetLog | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the WidgetLog we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends WidgetLogUpsertArgs>(args: Prisma.SelectSubset<T, WidgetLogUpsertArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of WidgetLogs. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogCountArgs} args - Arguments to filter WidgetLogs to count. | |
| * @example | |
| * // Count the number of WidgetLogs | |
| * const count = await prisma.widgetLog.count({ | |
| * where: { | |
| * // ... the filter for the WidgetLogs we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends WidgetLogCountArgs>( | |
| args?: Prisma.Subset<T, WidgetLogCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], WidgetLogCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a WidgetLog. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends WidgetLogAggregateArgs>(args: Prisma.Subset<T, WidgetLogAggregateArgs>): Prisma.PrismaPromise<GetWidgetLogAggregateType<T>> | |
| /** | |
| * Group by WidgetLog. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends WidgetLogGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: WidgetLogGroupByArgs['orderBy'] } | |
| : { orderBy?: WidgetLogGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, WidgetLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWidgetLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the WidgetLog model | |
| */ | |
| readonly fields: WidgetLogFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for WidgetLog. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__WidgetLogClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Widget<T extends Prisma.WidgetDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.WidgetDefaultArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the WidgetLog model | |
| */ | |
| export interface WidgetLogFieldRefs { | |
| readonly id: Prisma.FieldRef<"WidgetLog", 'String'> | |
| readonly oldOptions: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly newOptions: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly oldState: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly newState: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly widgetId: Prisma.FieldRef<"WidgetLog", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * WidgetLog findUnique | |
| */ | |
| export type WidgetLogFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog findUniqueOrThrow | |
| */ | |
| export type WidgetLogFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog findFirst | |
| */ | |
| export type WidgetLogFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of WidgetLogs. | |
| */ | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog findFirstOrThrow | |
| */ | |
| export type WidgetLogFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of WidgetLogs. | |
| */ | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog findMany | |
| */ | |
| export type WidgetLogFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLogs to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog create | |
| */ | |
| export type WidgetLogCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a WidgetLog. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogCreateInput, Prisma.WidgetLogUncheckedCreateInput> | |
| } | |
| /** | |
| * WidgetLog createMany | |
| */ | |
| export type WidgetLogCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many WidgetLogs. | |
| */ | |
| data: Prisma.WidgetLogCreateManyInput | Prisma.WidgetLogCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * WidgetLog createManyAndReturn | |
| */ | |
| export type WidgetLogCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many WidgetLogs. | |
| */ | |
| data: Prisma.WidgetLogCreateManyInput | Prisma.WidgetLogCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetLog update | |
| */ | |
| export type WidgetLogUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a WidgetLog. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateInput, Prisma.WidgetLogUncheckedUpdateInput> | |
| /** | |
| * Choose, which WidgetLog to update. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog updateMany | |
| */ | |
| export type WidgetLogUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update WidgetLogs. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyInput> | |
| /** | |
| * Filter which WidgetLogs to update | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * WidgetLog updateManyAndReturn | |
| */ | |
| export type WidgetLogUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * The data used to update WidgetLogs. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyInput> | |
| /** | |
| * Filter which WidgetLogs to update | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetLog upsert | |
| */ | |
| export type WidgetLogUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the WidgetLog to update in case it exists. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * In case the WidgetLog found by the `where` argument doesn't exist, create a new WidgetLog with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.WidgetLogCreateInput, Prisma.WidgetLogUncheckedCreateInput> | |
| /** | |
| * In case the WidgetLog was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.WidgetLogUpdateInput, Prisma.WidgetLogUncheckedUpdateInput> | |
| } | |
| /** | |
| * WidgetLog delete | |
| */ | |
| export type WidgetLogDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter which WidgetLog to delete. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog deleteMany | |
| */ | |
| export type WidgetLogDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which WidgetLogs to delete | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * WidgetLog without action | |
| */ | |
| export type WidgetLogDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/browser.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file should be your main import to use Prisma-related types and utilities in a browser. | |
| * Use it to get access to models, enums, and input types. | |
| * | |
| * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only. | |
| * See `client.ts` for the standard, server-side entry point. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import * as Prisma from './internal/prismaNamespaceBrowser' | |
| export { Prisma } | |
| export * as $Enums from './enums' | |
| export * from './enums'; | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type User = Prisma.UserModel | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type Session = Prisma.SessionModel | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type Dashboard = Prisma.DashboardModel | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type Widget = Prisma.WidgetModel | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLog = Prisma.WidgetLogModel | |
| ```` | |
| ## File: web/src/app/generated/prisma/client.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types. | |
| * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import * as processLocal from 'node:process' | |
| import * as path from 'node:path' | |
| import { fileURLToPath } from 'node:url' | |
| globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url)) | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import * as $Enums from "./enums" | |
| import * as $Class from "./internal/class" | |
| import * as Prisma from "./internal/prismaNamespace" | |
| export * as $Enums from './enums' | |
| export * from "./enums" | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| export const PrismaClient = $Class.getPrismaClientClass(__dirname) | |
| export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs> | |
| export { Prisma } | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type User = Prisma.UserModel | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type Session = Prisma.SessionModel | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type Dashboard = Prisma.DashboardModel | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type Widget = Prisma.WidgetModel | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLog = Prisma.WidgetLogModel | |
| ```` | |
| ## File: web/src/app/generated/prisma/commonInputTypes.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports various common sort, input & filter types that are not directly linked to a particular model. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import * as $Enums from "./enums" | |
| import type * as Prisma from "./internal/prismaNamespace" | |
| export type UuidFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedUuidFilter<$PrismaModel> | string | |
| } | |
| export type StringNullableFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null | |
| } | |
| export type JsonNullableFilter<$PrismaModel = never> = | |
| | Prisma.PatchUndefined< | |
| Prisma.Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>, | |
| Required<JsonNullableFilterBase<$PrismaModel>> | |
| > | |
| | Prisma.OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>> | |
| export type JsonNullableFilterBase<$PrismaModel = never> = { | |
| equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| path?: string[] | |
| mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel> | |
| string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| } | |
| export type BoolNullableFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableFilter<$PrismaModel> | boolean | null | |
| } | |
| export type DateTimeFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string | |
| } | |
| export type SortOrderInput = { | |
| sort: Prisma.SortOrder | |
| nulls?: Prisma.NullsOrder | |
| } | |
| export type UuidWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedUuidWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type StringNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| } | |
| export type JsonNullableWithAggregatesFilter<$PrismaModel = never> = | |
| | Prisma.PatchUndefined< | |
| Prisma.Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>, | |
| Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>> | |
| > | |
| | Prisma.OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>> | |
| export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = { | |
| equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| path?: string[] | |
| mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel> | |
| string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedJsonNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedJsonNullableFilter<$PrismaModel> | |
| } | |
| export type BoolNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| } | |
| export type DateTimeWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| } | |
| export type DateTimeNullableFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null | |
| } | |
| export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| } | |
| export type StringFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringFilter<$PrismaModel> | string | |
| } | |
| export type StringWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type IntNullableFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null | |
| } | |
| export type IntNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel> | |
| _sum?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| } | |
| export type NestedUuidFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedUuidFilter<$PrismaModel> | string | |
| } | |
| export type NestedStringNullableFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null | |
| } | |
| export type NestedBoolNullableFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableFilter<$PrismaModel> | boolean | null | |
| } | |
| export type NestedDateTimeFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string | |
| } | |
| export type NestedUuidWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedUuidWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type NestedIntFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntFilter<$PrismaModel> | number | |
| } | |
| export type NestedStringFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedStringFilter<$PrismaModel> | string | |
| } | |
| export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| } | |
| export type NestedIntNullableFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null | |
| } | |
| export type NestedJsonNullableFilter<$PrismaModel = never> = | |
| | Prisma.PatchUndefined< | |
| Prisma.Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>, | |
| Required<NestedJsonNullableFilterBase<$PrismaModel>> | |
| > | |
| | Prisma.OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>> | |
| export type NestedJsonNullableFilterBase<$PrismaModel = never> = { | |
| equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| path?: string[] | |
| mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel> | |
| string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| } | |
| export type NestedBoolNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| } | |
| export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| } | |
| export type NestedDateTimeNullableFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null | |
| } | |
| export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| } | |
| export type NestedStringWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel> | |
| _sum?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| } | |
| export type NestedFloatNullableFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.FloatFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.FloatFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.FloatFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.FloatFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null | |
| } | |
| ```` | |
| ## File: web/src/app/generated/prisma/enums.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports all enum related types from the schema. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| // This file is empty because there are no enums in the schema. | |
| export {} | |
| ```` | |
| ## File: web/src/app/generated/prisma/models.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This is a barrel export file for all models and their related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| export type * from './models/User' | |
| export type * from './models/Session' | |
| export type * from './models/Dashboard' | |
| export type * from './models/Widget' | |
| export type * from './models/WidgetLog' | |
| export type * from './commonInputTypes' | |
| ```` | |
| ## File: web/src/app/pages/dashboards.[dashboardId].delete.page.ts | |
| ````typescript | |
| import { AsyncPipe } from '@angular/common'; | |
| import { ChangeDetectionStrategy, Component, inject } from '@angular/core'; | |
| import { ActivatedRoute } from '@angular/router'; | |
| import { map, mergeMap, shareReplay, switchMap } from 'rxjs'; | |
| import { injectTrpcClient } from '../trpc-client'; | |
| @Component({ | |
| selector: 'delete-dashboard-page', | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| imports: [AsyncPipe], | |
| template: `<section> | |
| <h3> | |
| <nav aria-label="breadcrumb"> | |
| <ul> | |
| <li><a href="/dashboards">Dashboards</a></li> | |
| <li> | |
| <a href="/dashboards/{{ dashboardId$ | async }}" | |
| >Dashboard: {{ dashboardId$ | async }}</a | |
| > | |
| </li> | |
| <li>Delete</li> | |
| </ul> | |
| </nav> | |
| </h3> | |
| <hr /> | |
| @if ((dashboardId$ | async);as dashboardId){ Remove dashboard with id "{{ | |
| dashboardId | |
| }}" ? | |
| <div class="grid"> | |
| <a href="/dashboards/{{ dashboardId }}" type="button" class="secondary" | |
| >No</a | |
| > | |
| <button type="submit">Yes</button> | |
| </div> | |
| <hr /> | |
| } | |
| </section>`, | |
| }) | |
| export default class LoginPageComponent { | |
| private readonly trpc = injectTrpcClient(); | |
| private readonly route = inject(ActivatedRoute); | |
| readonly dashboardId$ = this.route.paramMap.pipe( | |
| map((params) => params.get('dashboardId')) | |
| ); | |
| } | |
| ```` | |
| ## File: web/src/app/pages/dashboards.[dashboardId].link-device.page.ts | |
| ````typescript | |
| import { AsyncPipe } from '@angular/common'; | |
| import { ChangeDetectionStrategy, Component, inject } from '@angular/core'; | |
| import { ActivatedRoute } from '@angular/router'; | |
| import { map, mergeMap, shareReplay, switchMap } from 'rxjs'; | |
| import { injectTrpcClient } from '../trpc-client'; | |
| @Component({ | |
| selector: 'link-device-to-dashboard-page', | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| imports: [AsyncPipe], | |
| template: `<section> | |
| <h3> | |
| <nav aria-label="breadcrumb"> | |
| <ul> | |
| <li><a href="/dashboards">Dashboards</a></li> | |
| <li> | |
| <a href="/dashboards/{{ dashboardId$ | async }}" | |
| >Dashboard: {{ dashboardId$ | async }}</a | |
| > | |
| </li> | |
| <li>Link device</li> | |
| </ul> | |
| </nav> | |
| </h3> | |
| <hr /> | |
| @if ((qrForLinkDevice$ | async);as qrForLinkDevice){ | |
| <img src="{{ qrForLinkDevice }}" alt="QR Code" /> | |
| <hr /> | |
| } | |
| </section>`, | |
| }) | |
| export default class LoginPageComponent { | |
| private readonly trpc = injectTrpcClient(); | |
| private readonly route = inject(ActivatedRoute); | |
| readonly dashboardId$ = this.route.paramMap.pipe( | |
| map((params) => params.get('dashboardId')) | |
| ); | |
| readonly qrForLinkDevice$ = this.route.paramMap.pipe( | |
| switchMap((params) => | |
| this.trpc.dashboards.linkDevice.query({ | |
| dashboardId: params.get('dashboardId')!, | |
| }) | |
| ), | |
| map((result) => result.qr), | |
| shareReplay(1) | |
| ); | |
| } | |
| ```` | |
| ## File: web/src/app/pages/dashboards.[dashboardId].page.ts | |
| ````typescript | |
| import { AsyncPipe } from '@angular/common'; | |
| import { ChangeDetectionStrategy, Component, inject } from '@angular/core'; | |
| import { ActivatedRoute } from '@angular/router'; | |
| import { map } from 'rxjs'; | |
| @Component({ | |
| selector: 'one-dashboard-page', | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| imports: [AsyncPipe], | |
| template: ` | |
| @if (dashboardId$ | async; as dashboardId){ | |
| <section> | |
| <h3> | |
| <nav aria-label="breadcrumb"> | |
| <ul> | |
| <li><a href="/dashboards">Dashboards</a></li> | |
| <li>Dashboard: {{ dashboardId }}</li> | |
| </ul> | |
| </nav> | |
| </h3> | |
| <hr /> | |
| <form> | |
| <input | |
| type="text" | |
| name="name" | |
| placeholder="Name" | |
| aria-label="Name" | |
| required | |
| /> | |
| <div class="grid"> | |
| <a | |
| href="/dashboards/{{ dashboardId }}/delete" | |
| type="button" | |
| class="secondary" | |
| >Remove</a | |
| > | |
| <a | |
| href="/dashboards/{{ dashboardId }}/link-device" | |
| type="button" | |
| class="contrast" | |
| >Link device</a | |
| > | |
| <button type="submit">Save</button> | |
| </div> | |
| </form> | |
| <hr /> | |
| </section> | |
| <h4>Widgets (2)</h4> | |
| <div class="grid"> | |
| <a href="/dashboards/{{ dashboardId }}/widgets/add-clock">Add clock</a> | |
| <a href="/dashboards/{{ dashboardId }}/widgets/add-calendar" | |
| >Add calendar</a | |
| > | |
| </div> | |
| <hr /> | |
| <details open> | |
| <summary> | |
| Clock <a href="/dashboards/{{ dashboardId }}/widgets/1">Edit</a> | |
| </summary> | |
| <p>ssdsd</p> | |
| </details> | |
| <hr /> | |
| <details open> | |
| <summary> | |
| Calendar <a href="/dashboards/{{ dashboardId }}/widgets/2">Edit</a> | |
| </summary> | |
| <p>ssdsd</p> | |
| </details> | |
| } | |
| `, | |
| }) | |
| export default class LoginPageComponent { | |
| private readonly route = inject(ActivatedRoute); | |
| readonly dashboardId$ = this.route.paramMap.pipe( | |
| map((params) => params.get('dashboardId')) | |
| ); | |
| } | |
| ```` | |
| ## File: web/src/app/pages/dashboards.page.ts | |
| ````typescript | |
| import { ChangeDetectionStrategy, Component } from '@angular/core'; | |
| @Component({ | |
| selector: 'dashboards-page', | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| template: `<section> | |
| <h3> | |
| <nav aria-label="breadcrumb"> | |
| <ul> | |
| <li>Dashboards</li> | |
| </ul> | |
| </nav> | |
| </h3> | |
| <a href="#">Create dashboard</a> | |
| <hr /> | |
| <details name="example" open> | |
| <summary>Мой старый андроид <a href="/dashboards/1">Edit</a></summary> | |
| <p>ssdsd</p> | |
| </details> | |
| <hr /> | |
| <details name="example"> | |
| <summary>Телефон Руслана <a href="#">Edit</a></summary> | |
| <ul> | |
| <li>dsds</li> | |
| <li>.dsdsd.</li> | |
| </ul> | |
| </details> | |
| </section>`, | |
| }) | |
| export default class DashboardsPageComponent {} | |
| ```` | |
| ## File: web/src/app/pages/login.page.ts | |
| ````typescript | |
| import { AsyncPipe } from '@angular/common'; | |
| import { ChangeDetectionStrategy, Component, inject } from '@angular/core'; | |
| import { Router } from '@angular/router'; | |
| import { first, tap } from 'rxjs'; | |
| import { NgxTelegramWidgetComponent } from '../components/telegram/ngx-telegram-widget.component'; | |
| import { AuthService } from '../services/auth.service'; | |
| import { TelegramSettingsService } from '../services/telegram-settings.service'; | |
| import { TelegramService } from '../services/telegram.service'; | |
| import { WINDOW } from '../utils/window'; | |
| @Component({ | |
| selector: 'login-page', | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| imports: [NgxTelegramWidgetComponent, AsyncPipe], | |
| template: `<section> | |
| <h3>Authorization</h3> | |
| <hr /> | |
| <form> | |
| <input | |
| type="text" | |
| name="username" | |
| placeholder="Username" | |
| aria-label="Username" | |
| autocomplete="username" | |
| required | |
| /> | |
| <input | |
| type="password" | |
| name="password" | |
| placeholder="Password" | |
| aria-label="Password" | |
| required | |
| /> | |
| <div class="grid"> | |
| <ngx-telegram-widget | |
| ngSkipHydration | |
| [botName]="(telegramSettings$ | async)?.authBotName!" | |
| (onAuth)="signInWithTelegramWidget($event)" | |
| hidden | |
| ></ngx-telegram-widget> | |
| <button type="button" (click)="signInWithTelegram()" class="secondary"> | |
| Login with Telegram | |
| </button> | |
| <button type="button" (click)="signInAsAnonymous()" class="contrast"> | |
| Login as Anonymous | |
| </button> | |
| <button type="submit">Login</button> | |
| </div> | |
| <a href="#" style="padding-right: 1rem;">Register</a> | |
| <a href="#">Password recovery</a> | |
| </form> | |
| </section>`, | |
| }) | |
| export default class LoginPageComponent { | |
| private authService = inject(AuthService); | |
| private router = inject(Router); | |
| private telegramService = inject(TelegramService); | |
| private telegramSettingsService = inject(TelegramSettingsService); | |
| telegramSettings$ = this.telegramSettingsService.stream$; | |
| signInAsAnonymous() { | |
| this.authService | |
| .signInAsAnonymous() | |
| .pipe( | |
| first(), | |
| tap(() => this.router.navigate(['/dashboards'])) | |
| ) | |
| .subscribe(); | |
| } | |
| signInWithTelegramWidget(telegramUser: unknown) { | |
| this.telegramService | |
| .signInWithTelegram(telegramUser) | |
| .pipe( | |
| first(), | |
| tap(() => this.router.navigate(['/dashboards'])) | |
| ) | |
| .subscribe(); | |
| } | |
| signInWithTelegram() { | |
| WINDOW?.Telegram?.Login.auth( | |
| { | |
| bot_id: this.telegramSettingsService.get()?.authBotId, | |
| request_access: true, | |
| }, | |
| (telegramUser: unknown) => { | |
| this.telegramService | |
| .signInWithTelegram(telegramUser) | |
| .pipe( | |
| first(), | |
| tap(() => this.router.navigate(['/dashboards'])) | |
| ) | |
| .subscribe(); | |
| } | |
| ); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/auth.service.ts | |
| ````typescript | |
| import { inject, Injectable } from '@angular/core'; | |
| import { catchError, of, tap } from 'rxjs'; | |
| import { User } from '../generated/prisma/browser'; | |
| import { injectTrpcClient } from '../trpc-client'; | |
| import { ProfileService } from './profile.service'; | |
| import { SessionService } from './session.service'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class AuthService { | |
| private trpc = injectTrpcClient(); | |
| private sessionService = inject(SessionService); | |
| private profileService = inject(ProfileService); | |
| signInAsAnonymous() { | |
| return this.trpc.auth.signInAsAnonymous.mutate().pipe( | |
| tap(({ sessionId, user }) => { | |
| this.sessionService.set(sessionId); | |
| this.profileService.set(user as unknown as User); | |
| }) | |
| ); | |
| } | |
| signOut() { | |
| return this.trpc.auth.signOut.mutate().pipe( | |
| tap(() => { | |
| this.sessionService.remove(); | |
| this.profileService.remove(); | |
| }) | |
| ); | |
| } | |
| profile() { | |
| this.sessionService.reload(); | |
| return this.trpc.auth.profile.query().pipe( | |
| tap((profile) => { | |
| this.profileService.set(profile as unknown as User); | |
| return profile; | |
| }), | |
| catchError((err) => { | |
| this.sessionService.remove(); | |
| this.profileService.remove(); | |
| return of(null); | |
| }) | |
| ); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/local-storage.service.ts | |
| ````typescript | |
| import { Injectable } from '@angular/core'; | |
| import { BehaviorSubject } from 'rxjs'; | |
| import { LOCAL_STORAGE } from '../utils/local-storage'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class LocalStorageService<T = unknown> { | |
| key?: string; | |
| private storageChangeSubject = new BehaviorSubject<{ | |
| key: string | null; | |
| newValue: T | null; | |
| oldValue: T | null; | |
| url: string | null; | |
| storageArea: Storage | null; | |
| }>({ | |
| key: null, | |
| newValue: null, | |
| oldValue: null, | |
| url: null, | |
| storageArea: null, | |
| }); | |
| storageChanges = this.storageChangeSubject.asObservable(); | |
| constructor() { | |
| if (this.key) { | |
| this.reload(); | |
| } | |
| } | |
| reload() { | |
| const current = this.get(); | |
| if (current) { | |
| this.set(current); | |
| } | |
| } | |
| set(value: T): void { | |
| if (!this.key) { | |
| throw new Error('this.key not set'); | |
| } | |
| this.setItem(this.key, value); | |
| } | |
| get(): T | null { | |
| if (!this.key) { | |
| throw new Error('this.key not set'); | |
| } | |
| return this.getItem(this.key); | |
| } | |
| remove() { | |
| if (!this.key) { | |
| throw new Error('this.key not set'); | |
| } | |
| this.removeItem(this.key); | |
| } | |
| setItem(key: string, value: T): void { | |
| const newValue = JSON.stringify(value); | |
| const oldValueRaw = LOCAL_STORAGE?.getItem(key); | |
| const oldValue = | |
| oldValueRaw && oldValueRaw !== 'undefined' | |
| ? JSON.parse(oldValueRaw) | |
| : oldValueRaw; | |
| LOCAL_STORAGE?.setItem(key, newValue); | |
| this.storageChangeSubject.next({ | |
| key, | |
| newValue: value, | |
| oldValue, | |
| url: null, | |
| storageArea: LOCAL_STORAGE, | |
| }); | |
| } | |
| getItem(key: string): T | null { | |
| try { | |
| const value = LOCAL_STORAGE?.getItem(key); | |
| if (value && value !== 'undefined') { | |
| return JSON.parse(value); | |
| } | |
| return null; | |
| } catch (error) { | |
| return null; | |
| } | |
| } | |
| removeItem(key: string): void { | |
| const oldValue = this.getItem(key); | |
| LOCAL_STORAGE?.removeItem(key); | |
| this.storageChangeSubject.next({ | |
| key, | |
| newValue: null, | |
| oldValue, | |
| url: null, | |
| storageArea: LOCAL_STORAGE, | |
| }); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/modal.component.ts | |
| ````typescript | |
| import { DOCUMENT } from '@angular/common'; | |
| import { | |
| ChangeDetectionStrategy, | |
| Component, | |
| EventEmitter, | |
| HostListener, | |
| OnDestroy, | |
| OnInit, | |
| Output, | |
| booleanAttribute, | |
| inject, | |
| input, | |
| signal, | |
| } from '@angular/core'; | |
| import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop'; | |
| import { Subject, delay, filter, skip, tap } from 'rxjs'; | |
| import { isSSR } from '../utils/is-ssr'; | |
| import { WINDOW } from '../utils/window'; | |
| const modalAnimationDuration = 400; | |
| @Component({ | |
| selector: 'modal', | |
| standalone: true, | |
| changeDetection: ChangeDetectionStrategy.OnPush, | |
| template: ` | |
| <dialog #dialog (click)="overlayClicked($event)" [open]="isModalOpen()"> | |
| <article> | |
| <header> | |
| <button aria-label="Close" rel="prev" (click)="close.emit()"></button> | |
| <h3>Confirm your action!</h3> | |
| </header> | |
| <p> | |
| Cras sit amet maximus risus. Pellentesque sodales odio sit amet augue | |
| finibus pellentesque. Nullam finibus risus non semper euismod. | |
| </p> | |
| <footer> | |
| <button class="secondary" (click)="close.emit()">Cancel</button> | |
| <button (click)="close.emit()">Confirm</button> | |
| </footer> | |
| </article> | |
| </dialog> | |
| `, | |
| }) | |
| export class ModalComponent implements OnInit, OnDestroy { | |
| readonly #htmlEl: HTMLElement = inject(DOCUMENT).documentElement; | |
| readonly isModalOpen = signal<boolean>(false); | |
| readonly open = input.required({ transform: booleanAttribute }); | |
| @Output() close = new EventEmitter<void>(); | |
| @HostListener('document:keydown.escape') | |
| handleEscapeKey() { | |
| if (this.isModalOpen()) { | |
| this.close.emit(); | |
| } | |
| } | |
| readonly #closeModal$ = new Subject<void>(); | |
| readonly #openModal$ = new Subject<void>(); | |
| constructor() { | |
| this.#closeModal$ | |
| .pipe( | |
| takeUntilDestroyed(), | |
| tap(() => this.#htmlEl.classList.add('modal-is-closing')), | |
| delay(modalAnimationDuration), | |
| tap(() => this.isModalOpen.set(false)), | |
| tap(() => | |
| this.#htmlEl.classList.remove('modal-is-open', 'modal-is-closing') | |
| ) | |
| ) | |
| .subscribe(); | |
| this.#openModal$ | |
| .pipe( | |
| takeUntilDestroyed(), | |
| tap(() => this.isModalOpen.set(true)), | |
| tap(() => | |
| this.#htmlEl.classList.add('modal-is-open', 'modal-is-opening') | |
| ), | |
| delay(modalAnimationDuration), | |
| tap(() => this.#htmlEl.classList.remove('modal-is-opening')) | |
| ) | |
| .subscribe(); | |
| toObservable(this.open) | |
| .pipe( | |
| takeUntilDestroyed(), | |
| skip(1), | |
| filter((shouldOpen) => shouldOpen !== this.isModalOpen()), | |
| tap((shouldOpen) => | |
| shouldOpen ? this.#openModal$.next() : this.#closeModal$.next() | |
| ) | |
| ) | |
| .subscribe(); | |
| } | |
| ngOnInit(): void { | |
| const scrollBarWidth = this.getScrollBarWidth(); | |
| this.#htmlEl.style.setProperty( | |
| '--pico-scrollbar-width', | |
| `${scrollBarWidth}px` | |
| ); | |
| } | |
| ngOnDestroy(): void { | |
| this.#htmlEl.style.removeProperty('--pico-scrollbar-width'); | |
| } | |
| getScrollBarWidth(): number { | |
| if (isSSR) return 0; | |
| const hasScrollbar = document.body.scrollHeight > screen.height; | |
| if (hasScrollbar) { | |
| const scrollbarWidth = | |
| WINDOW.innerWidth - document.documentElement.clientWidth; | |
| return scrollbarWidth; | |
| } | |
| return 0; | |
| } | |
| overlayClicked(event: MouseEvent): void { | |
| if (event.target === event.currentTarget) { | |
| this.close.emit(); | |
| } | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/profile.service.ts | |
| ````typescript | |
| import { Injectable } from '@angular/core'; | |
| import { map } from 'rxjs'; | |
| import { User } from '../generated/prisma/browser'; | |
| import { LocalStorageService } from './local-storage.service'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class ProfileService extends LocalStorageService<User> { | |
| override key = 'profile'; | |
| stream$ = this.storageChanges.pipe(map((e) => e.newValue)); | |
| isLoggedIn() { | |
| return this.storageChanges.pipe( | |
| map(({ newValue }) => !!newValue && !!newValue.id) | |
| ); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/session.service.ts | |
| ````typescript | |
| import { Injectable, OnDestroy } from '@angular/core'; | |
| import { map, tap } from 'rxjs'; | |
| import { X_SESSION_ID } from '../../server/constants'; | |
| import { TrpcHeaders } from '../trpc-client'; | |
| import { LocalStorageService } from './local-storage.service'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class SessionService | |
| extends LocalStorageService<string> | |
| implements OnDestroy | |
| { | |
| override key = 'sessionId'; | |
| stream$ = this.storageChanges.pipe( | |
| map((e) => e.newValue), | |
| tap((sessionId) => { | |
| if (sessionId) { | |
| TrpcHeaders.set({ [X_SESSION_ID]: sessionId }); | |
| } else { | |
| TrpcHeaders.set({}); | |
| } | |
| }) | |
| ); | |
| private streamRef = this.stream$.subscribe(); | |
| ngOnDestroy(): void { | |
| this.streamRef.unsubscribe(); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/telegram-settings.service.ts | |
| ````typescript | |
| import { Injectable } from '@angular/core'; | |
| import { map } from 'rxjs'; | |
| import { TelegramSettingsType } from '../../server/types/TelegramSettingsSchema'; | |
| import { LocalStorageService } from './local-storage.service'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class TelegramSettingsService | |
| extends LocalStorageService<TelegramSettingsType> | |
| { | |
| override key = 'telegramSettings'; | |
| stream$ = this.storageChanges.pipe(map((e) => e.newValue)); | |
| } | |
| ```` | |
| ## File: web/src/app/services/telegram.service.ts | |
| ````typescript | |
| import { inject, Injectable } from '@angular/core'; | |
| import { tap } from 'rxjs'; | |
| import { TelegramUserDataType } from '../../server/types/TelegramUserDataSchema'; | |
| import { User } from '../generated/prisma/browser'; | |
| import { injectTrpcClient } from '../trpc-client'; | |
| import { ProfileService } from './profile.service'; | |
| import { SessionService } from './session.service'; | |
| import { TelegramSettingsService } from './telegram-settings.service'; | |
| @Injectable({ | |
| providedIn: 'root', | |
| }) | |
| export class TelegramService { | |
| private trpc = injectTrpcClient(); | |
| private sessionService = inject(SessionService); | |
| private profileService = inject(ProfileService); | |
| private telegramSettingsService = inject(TelegramSettingsService); | |
| getSettings() { | |
| return this.trpc.telegram.settings.query().pipe( | |
| tap((settings) => { | |
| this.telegramSettingsService.set(settings); | |
| }) | |
| ); | |
| } | |
| signInWithTelegram(telegramUser: unknown) { | |
| return this.trpc.telegram.signIn | |
| .mutate(telegramUser as TelegramUserDataType) | |
| .pipe( | |
| tap(({ sessionId, user }) => { | |
| this.sessionService.set(sessionId); | |
| this.profileService.set(user as unknown as User); | |
| }) | |
| ); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/services/theme.service.ts | |
| ````typescript | |
| import { Injectable, OnDestroy } from '@angular/core'; | |
| import { distinctUntilChanged, map, tap } from 'rxjs'; | |
| import { isSSR } from '../utils/is-ssr'; | |
| import { WINDOW } from '../utils/window'; | |
| import { LocalStorageService } from './local-storage.service'; | |
| export type ColorScheme = 'light' | 'dark'; | |
| const htmlTag = !isSSR && document.querySelector('html'); | |
| const defaultTheme: ColorScheme = WINDOW?.matchMedia?.( | |
| '(prefers-color-scheme: dark)' | |
| ).matches | |
| ? 'dark' | |
| : 'light'; | |
| @Injectable({ providedIn: 'root' }) | |
| export class ThemeService | |
| extends LocalStorageService<ColorScheme> | |
| implements OnDestroy | |
| { | |
| override key = 'picoColorScheme'; | |
| stream$ = this.storageChanges.pipe( | |
| map((e) => e.newValue), | |
| tap((theme) => { | |
| if (!theme) { | |
| this.set('light'); | |
| } else { | |
| if (htmlTag) { | |
| htmlTag.setAttribute('data-theme', theme); | |
| } | |
| } | |
| }) | |
| ); | |
| switchTheme(): void { | |
| const currentTheme = this.get(); | |
| const newTheme = !currentTheme | |
| ? defaultTheme | |
| : currentTheme === 'light' | |
| ? 'dark' | |
| : 'light'; | |
| this.set(newTheme); | |
| } | |
| private streamRef = this.stream$.subscribe(); | |
| ngOnDestroy(): void { | |
| this.streamRef.unsubscribe(); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/utils/is-ssr.ts | |
| ````typescript | |
| export const isSSR = typeof window === 'undefined'; | |
| ```` | |
| ## File: web/src/app/utils/local-storage.ts | |
| ````typescript | |
| export const LOCAL_STORAGE = | |
| typeof localStorage !== 'undefined' ? (localStorage as any) : undefined; | |
| ```` | |
| ## File: web/src/app/utils/window.ts | |
| ````typescript | |
| export const WINDOW = | |
| typeof window !== 'undefined' ? (window as any) : undefined; | |
| ```` | |
| ## File: web/src/app/app.config.server.ts | |
| ````typescript | |
| import { mergeApplicationConfig, ApplicationConfig } from '@angular/core'; | |
| import { provideServerRendering } from '@angular/platform-server'; | |
| import { appConfig } from './app.config'; | |
| const serverConfig: ApplicationConfig = { | |
| providers: [provideServerRendering()], | |
| }; | |
| export const config = mergeApplicationConfig(appConfig, serverConfig); | |
| ```` | |
| ## File: web/src/app/app.config.ts | |
| ````typescript | |
| import { | |
| provideHttpClient, | |
| withFetch, | |
| withInterceptors, | |
| } from '@angular/common/http'; | |
| import { | |
| ApplicationConfig, | |
| provideBrowserGlobalErrorListeners, | |
| provideZoneChangeDetection | |
| } from '@angular/core'; | |
| import { provideClientHydration, withEventReplay } from '@angular/platform-browser'; | |
| import { provideFileRouter, requestContextInterceptor } from '@analogjs/router'; | |
| import { provideTrpcClient } from './trpc-client'; | |
| import { withComponentInputBinding } from '@angular/router'; | |
| export const appConfig: ApplicationConfig = { | |
| providers: [ | |
| provideBrowserGlobalErrorListeners(), | |
| provideZoneChangeDetection({ eventCoalescing: true }), | |
| provideFileRouter(withComponentInputBinding()), | |
| provideHttpClient( | |
| withFetch(), | |
| withInterceptors([requestContextInterceptor]) | |
| ), | |
| provideClientHydration(withEventReplay()), | |
| provideTrpcClient() | |
| ], | |
| }; | |
| ```` | |
| ## File: web/src/app/app.spec.ts | |
| ````typescript | |
| import { TestBed } from '@angular/core/testing'; | |
| import { provideRouter } from '@angular/router'; | |
| import { provideLocationMocks } from '@angular/common/testing'; | |
| import { AppComponent } from './app'; | |
| describe('AppComponent', () => { | |
| beforeEach(async () => { | |
| await TestBed.configureTestingModule({ | |
| imports: [AppComponent], | |
| providers: [provideRouter([]), provideLocationMocks()], | |
| }).compileComponents(); | |
| }); | |
| it('should create the app', () => { | |
| const fixture = TestBed.createComponent(AppComponent); | |
| const app = fixture.componentInstance; | |
| expect(app).toBeTruthy(); | |
| }); | |
| }); | |
| ```` | |
| ## File: web/src/app/app.ts | |
| ````typescript | |
| import { Component, inject } from '@angular/core'; | |
| import { Router, RouterOutlet } from '@angular/router'; | |
| import { first, forkJoin, merge, tap } from 'rxjs'; | |
| import { ColorSchemeSwitcherComponent } from './components/theme/color-scheme-switcher.component'; | |
| import { | |
| IfLoggedDirective, | |
| IfNotLoggedDirective, | |
| } from './directives/ if-logged.directive'; | |
| import { AuthService } from './services/auth.service'; | |
| import { TelegramService } from './services/telegram.service'; | |
| @Component({ | |
| selector: 'app-root', | |
| imports: [ | |
| RouterOutlet, | |
| ColorSchemeSwitcherComponent, | |
| IfNotLoggedDirective, | |
| IfLoggedDirective, | |
| ], | |
| template: ` <header class="container"> | |
| <nav> | |
| <ul> | |
| <li> | |
| <h1><a href="/">My Dashboard</a></h1> | |
| </li> | |
| </ul> | |
| <ul> | |
| <li><a href="/dashboards">Dashboards</a></li> | |
| <li><a href="/login" *ifNotLogged>Login</a></li> | |
| <li><a href="#signOut" (click)="signOut()" *ifLogged>Logout</a></li> | |
| <li><color-scheme-switcher /></li> | |
| </ul> | |
| </nav> | |
| </header> | |
| <main class="container"> | |
| <router-outlet></router-outlet> | |
| </main> | |
| <footer class="container"> | |
| <nav> | |
| <ul> | |
| <li>Copyright © 2025 MyDashboard. Licensed under MIT.</li> | |
| </ul> | |
| <ul> | |
| <li><a href="#">Source code</a></li> | |
| <li><a href="#">Telegram group</a></li> | |
| </ul> | |
| </nav> | |
| </footer>`, | |
| }) | |
| export class AppComponent { | |
| private authService = inject(AuthService); | |
| private telegramService = inject(TelegramService); | |
| constructor() { | |
| forkJoin([this.authService.profile(), this.telegramService.getSettings()]) | |
| .pipe(first()) | |
| .subscribe(); | |
| } | |
| private router = inject(Router); | |
| signOut() { | |
| this.authService | |
| .signOut() | |
| .pipe( | |
| first(), | |
| tap(() => this.router.navigate(['/'])) | |
| ) | |
| .subscribe(); | |
| } | |
| } | |
| ```` | |
| ## File: web/src/app/trpc-client.ts | |
| ````typescript | |
| import { AppRouter } from '../server/trpc/routers/index'; | |
| import { createTrpcClient } from '@analogjs/trpc'; | |
| import { inject } from '@angular/core'; | |
| export const { provideTrpcClient, TrpcClient, TrpcHeaders } = | |
| createTrpcClient<AppRouter>({ | |
| url: '/api/trpc', | |
| }); | |
| export function injectTrpcClient() { | |
| return inject(TrpcClient); | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/internal/class.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * Please import the `PrismaClient` class from the `client.ts` file instead. | |
| */ | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import type * as Prisma from "./prismaNamespace" | |
| const config: runtime.GetPrismaClientConfig = { | |
| "generator": { | |
| "name": "client2", | |
| "provider": { | |
| "fromEnvVar": null, | |
| "value": "prisma-client" | |
| }, | |
| "output": { | |
| "value": "/home/endy/Projects/site15/my-dashboard/web/src/server/generated/prisma", | |
| "fromEnvVar": null | |
| }, | |
| "config": { | |
| "engineType": "client" | |
| }, | |
| "binaryTargets": [ | |
| { | |
| "fromEnvVar": null, | |
| "value": "debian-openssl-3.0.x", | |
| "native": true | |
| } | |
| ], | |
| "previewFeatures": [], | |
| "sourceFilePath": "/home/endy/Projects/site15/my-dashboard/web/prisma/schema.prisma", | |
| "isCustomOutput": true | |
| }, | |
| "relativePath": "../../../../prisma", | |
| "clientVersion": "6.19.0", | |
| "engineVersion": "2ba551f319ab1df4bc874a89965d8b3641056773", | |
| "datasourceNames": [ | |
| "db" | |
| ], | |
| "activeProvider": "postgresql", | |
| "postinstall": false, | |
| "inlineDatasources": { | |
| "db": { | |
| "url": { | |
| "fromEnvVar": "MY_DASHBOARD_DATABASE_POSTGRES_URL", | |
| "value": null | |
| } | |
| } | |
| }, | |
| "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\n// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?\n// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init\n\ngenerator client1 {\n provider = \"prisma-client\"\n output = \"../src/app/generated/prisma\"\n engineType = \"client\"\n}\n\ngenerator client2 {\n provider = \"prisma-client\"\n output = \"../src/server/generated/prisma\"\n engineType = \"client\"\n}\n\ndatasource db {\n provider = \"postgresql\"\n url = env(\"MY_DASHBOARD_DATABASE_POSTGRES_URL\")\n}\n\nmodel User {\n id String @id(map: \"PK_USER\") @default(uuid()) @db.Uuid\n anonymousId String?\n telegramUserId String?\n telegramUserData Json?\n isBlackTheme Boolean?\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n Session Session[]\n Dashboard Dashboard[]\n\n @@unique([telegramUserId], map: \"UQ_USER\")\n}\n\nmodel Session {\n id String @id(map: \"PK_SESSION\") @default(uuid()) @db.Uuid\n userId String @db.Uuid\n User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_SESSION__USER_ID\")\n createdAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([userId], map: \"IDX_SESSION__USER_ID\")\n}\n\nmodel Dashboard {\n id String @id(map: \"PK_DASHBOARD\") @default(uuid()) @db.Uuid\n name String\n deviceId String?\n userId String @db.Uuid\n isBlackTheme Boolean?\n User User @relation(fields: [userId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_DASHBOARD__USER_ID\")\n Widget Widget[]\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@unique([userId, name], map: \"UQ_DASHBOARD__USER_ID_NAME\")\n @@unique([deviceId], map: \"UQ_DASHBOARD__DEVICE_ID\")\n @@index([userId], map: \"IDX_DASHBOARD__USER_ID\")\n}\n\nmodel Widget {\n id String @id(map: \"PK_WIDGET\") @default(uuid()) @db.Uuid\n options Json?\n state Json?\n columnIndex Int?\n rowIndex Int?\n columnCount Int?\n rowCount Int?\n\n isBlackTheme Boolean?\n backgroundColor String?\n primaryColor String?\n positiveColor String?\n negativeColor String?\n // contrastMultiplier Float\n // textSaturationMultiplier Float\n\n dashboardId String @db.Uuid\n Dashboard Dashboard @relation(fields: [dashboardId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_WIDGET__DASHBOARD_ID\")\n WidgetLog WidgetLog[]\n\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([dashboardId], map: \"IDX_WIDGET__DASHBOARD_ID\")\n}\n\nmodel WidgetLog {\n id String @id(map: \"PK_WIDGET_LOG\") @default(uuid()) @db.Uuid\n oldOptions Json?\n newOptions Json?\n oldState Json?\n newState Json?\n\n widgetId String @db.Uuid\n Widget Widget @relation(fields: [widgetId], references: [id], onDelete: NoAction, onUpdate: NoAction, map: \"FK_WIDGET_LOG__WIDGET_ID\")\n createdAt DateTime @default(now())\n updatedAt DateTime @default(now())\n deletedAt DateTime?\n\n @@index([widgetId], map: \"IDX_WIDGET_LOG__WIDGET_ID\")\n}\n", | |
| "inlineSchemaHash": "aeef395d84970501273720149484679e38b6223b1abad17440ba39f57339891d", | |
| "copyEngine": true, | |
| "runtimeDataModel": { | |
| "models": {}, | |
| "enums": {}, | |
| "types": {} | |
| }, | |
| "dirname": "" | |
| } | |
| config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"anonymousId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"telegramUserId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"telegramUserData\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"Session\",\"kind\":\"object\",\"type\":\"Session\",\"relationName\":\"SessionToUser\"},{\"name\":\"Dashboard\",\"kind\":\"object\",\"type\":\"Dashboard\",\"relationName\":\"DashboardToUser\"}],\"dbName\":null},\"Session\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"User\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SessionToUser\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"Dashboard\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"name\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"deviceId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"User\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"DashboardToUser\"},{\"name\":\"Widget\",\"kind\":\"object\",\"type\":\"Widget\",\"relationName\":\"DashboardToWidget\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"Widget\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"options\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"state\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"columnIndex\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"rowIndex\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"columnCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"rowCount\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"isBlackTheme\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"backgroundColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"primaryColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"positiveColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"negativeColor\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"dashboardId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"Dashboard\",\"kind\":\"object\",\"type\":\"Dashboard\",\"relationName\":\"DashboardToWidget\"},{\"name\":\"WidgetLog\",\"kind\":\"object\",\"type\":\"WidgetLog\",\"relationName\":\"WidgetToWidgetLog\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"WidgetLog\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"oldOptions\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"newOptions\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"oldState\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"newState\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"widgetId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"Widget\",\"kind\":\"object\",\"type\":\"Widget\",\"relationName\":\"WidgetToWidgetLog\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"deletedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null}},\"enums\":{},\"types\":{}}") | |
| config.engineWasm = undefined | |
| async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> { | |
| const { Buffer } = await import('node:buffer') | |
| const wasmArray = Buffer.from(wasmBase64, 'base64') | |
| return new WebAssembly.Module(wasmArray) | |
| } | |
| config.compilerWasm = { | |
| getRuntime: async () => await import("@prisma/client/runtime/query_compiler_bg.postgresql.mjs"), | |
| getQueryCompilerWasmModule: async () => { | |
| const { wasm } = await import("@prisma/client/runtime/query_compiler_bg.postgresql.wasm-base64.mjs") | |
| return await decodeBase64AsWasm(wasm) | |
| } | |
| } | |
| export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> = | |
| 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never | |
| export interface PrismaClientConstructor { | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| new < | |
| Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, | |
| LogOpts extends LogOptions<Options> = LogOptions<Options>, | |
| OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends { omit: infer U } ? U : Prisma.PrismaClientOptions['omit'], | |
| ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs | |
| >(options?: Prisma.Subset<Options, Prisma.PrismaClientOptions> ): PrismaClient<LogOpts, OmitOpts, ExtArgs> | |
| } | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| export interface PrismaClient< | |
| in LogOpts extends Prisma.LogLevel = never, | |
| in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = Prisma.PrismaClientOptions['omit'], | |
| in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs | |
| > { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] } | |
| $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient; | |
| /** | |
| * Connect with the database | |
| */ | |
| $connect(): runtime.Types.Utils.JsPromise<void>; | |
| /** | |
| * Disconnect from the database | |
| */ | |
| $disconnect(): runtime.Types.Utils.JsPromise<void>; | |
| /** | |
| * Executes a prepared raw query and returns the number of affected rows. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'[email protected]'};` | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>; | |
| /** | |
| * Executes a raw query and returns the number of affected rows. | |
| * Susceptible to SQL injections, see documentation. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, '[email protected]') | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>; | |
| /** | |
| * Performs a prepared raw query and returns the `SELECT` data. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'[email protected]'};` | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>; | |
| /** | |
| * Performs a raw query and returns the `SELECT` data. | |
| * Susceptible to SQL injections, see documentation. | |
| * @example | |
| * ``` | |
| * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, '[email protected]') | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). | |
| */ | |
| $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>; | |
| /** | |
| * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole. | |
| * @example | |
| * ``` | |
| * const [george, bob, alice] = await prisma.$transaction([ | |
| * prisma.user.create({ data: { name: 'George' } }), | |
| * prisma.user.create({ data: { name: 'Bob' } }), | |
| * prisma.user.create({ data: { name: 'Alice' } }), | |
| * ]) | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions). | |
| */ | |
| $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>> | |
| $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<R> | |
| $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, { | |
| extArgs: ExtArgs | |
| }>> | |
| /** | |
| * `prisma.user`: Exposes CRUD operations for the **User** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| */ | |
| get user(): Prisma.UserDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.session`: Exposes CRUD operations for the **Session** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Sessions | |
| * const sessions = await prisma.session.findMany() | |
| * ``` | |
| */ | |
| get session(): Prisma.SessionDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.dashboard`: Exposes CRUD operations for the **Dashboard** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Dashboards | |
| * const dashboards = await prisma.dashboard.findMany() | |
| * ``` | |
| */ | |
| get dashboard(): Prisma.DashboardDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.widget`: Exposes CRUD operations for the **Widget** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more Widgets | |
| * const widgets = await prisma.widget.findMany() | |
| * ``` | |
| */ | |
| get widget(): Prisma.WidgetDelegate<ExtArgs, { omit: OmitOpts }>; | |
| /** | |
| * `prisma.widgetLog`: Exposes CRUD operations for the **WidgetLog** model. | |
| * Example usage: | |
| * ```ts | |
| * // Fetch zero or more WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany() | |
| * ``` | |
| */ | |
| get widgetLog(): Prisma.WidgetLogDelegate<ExtArgs, { omit: OmitOpts }>; | |
| } | |
| export function getPrismaClientClass(dirname: string): PrismaClientConstructor { | |
| config.dirname = dirname | |
| return runtime.getPrismaClient(config) as unknown as PrismaClientConstructor | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/internal/prismaNamespace.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * All exports from this file are wrapped under a `Prisma` namespace object in the client.ts file. | |
| * While this enables partial backward compatibility, it is not part of the stable public API. | |
| * | |
| * If you are looking for your Models, Enums, and Input Types, please import them from the respective | |
| * model files in the `model` directory! | |
| */ | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import type * as Prisma from "../models" | |
| import { type PrismaClient } from "./class" | |
| export type * from '../models' | |
| export type DMMF = typeof runtime.DMMF | |
| export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T> | |
| /** | |
| * Prisma Errors | |
| */ | |
| export const PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError | |
| export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError | |
| export const PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError | |
| export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError | |
| export const PrismaClientRustPanicError = runtime.PrismaClientRustPanicError | |
| export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError | |
| export const PrismaClientInitializationError = runtime.PrismaClientInitializationError | |
| export type PrismaClientInitializationError = runtime.PrismaClientInitializationError | |
| export const PrismaClientValidationError = runtime.PrismaClientValidationError | |
| export type PrismaClientValidationError = runtime.PrismaClientValidationError | |
| /** | |
| * Re-export of sql-template-tag | |
| */ | |
| export const sql = runtime.sqltag | |
| export const empty = runtime.empty | |
| export const join = runtime.join | |
| export const raw = runtime.raw | |
| export const Sql = runtime.Sql | |
| export type Sql = runtime.Sql | |
| /** | |
| * Decimal.js | |
| */ | |
| export const Decimal = runtime.Decimal | |
| export type Decimal = runtime.Decimal | |
| export type DecimalJsLike = runtime.DecimalJsLike | |
| /** | |
| * Metrics | |
| */ | |
| export type Metrics = runtime.Metrics | |
| export type Metric<T> = runtime.Metric<T> | |
| export type MetricHistogram = runtime.MetricHistogram | |
| export type MetricHistogramBucket = runtime.MetricHistogramBucket | |
| /** | |
| * Extensions | |
| */ | |
| export type Extension = runtime.Types.Extensions.UserArgs | |
| export const getExtensionContext = runtime.Extensions.getExtensionContext | |
| export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F> | |
| export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F> | |
| export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F> | |
| export type Exact<A, W> = runtime.Types.Public.Exact<A, W> | |
| export type PrismaVersion = { | |
| client: string | |
| engine: string | |
| } | |
| /** | |
| * Prisma Client JS version: 6.19.0 | |
| * Query Engine version: 2ba551f319ab1df4bc874a89965d8b3641056773 | |
| */ | |
| export const prismaVersion: PrismaVersion = { | |
| client: "6.19.0", | |
| engine: "2ba551f319ab1df4bc874a89965d8b3641056773" | |
| } | |
| /** | |
| * Utility Types | |
| */ | |
| export type Bytes = runtime.Bytes | |
| export type JsonObject = runtime.JsonObject | |
| export type JsonArray = runtime.JsonArray | |
| export type JsonValue = runtime.JsonValue | |
| export type InputJsonObject = runtime.InputJsonObject | |
| export type InputJsonArray = runtime.InputJsonArray | |
| export type InputJsonValue = runtime.InputJsonValue | |
| export const NullTypes = { | |
| DbNull: runtime.objectEnumValues.classes.DbNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.DbNull), | |
| JsonNull: runtime.objectEnumValues.classes.JsonNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.JsonNull), | |
| AnyNull: runtime.objectEnumValues.classes.AnyNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.AnyNull), | |
| } | |
| /** | |
| * Helper for filtering JSON entries that have `null` on the database (empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const DbNull = runtime.objectEnumValues.instances.DbNull | |
| /** | |
| * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const JsonNull = runtime.objectEnumValues.instances.JsonNull | |
| /** | |
| * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const AnyNull = runtime.objectEnumValues.instances.AnyNull | |
| type SelectAndInclude = { | |
| select: any | |
| include: any | |
| } | |
| type SelectAndOmit = { | |
| select: any | |
| omit: any | |
| } | |
| /** | |
| * From T, pick a set of properties whose keys are in the union K | |
| */ | |
| type Prisma__Pick<T, K extends keyof T> = { | |
| [P in K]: T[P]; | |
| }; | |
| export type Enumerable<T> = T | Array<T>; | |
| /** | |
| * Subset | |
| * @desc From `T` pick properties that exist in `U`. Simple version of Intersection | |
| */ | |
| export type Subset<T, U> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never; | |
| }; | |
| /** | |
| * SelectSubset | |
| * @desc From `T` pick properties that exist in `U`. Simple version of Intersection. | |
| * Additionally, it validates, if both select and include are present. If the case, it errors. | |
| */ | |
| export type SelectSubset<T, U> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never | |
| } & | |
| (T extends SelectAndInclude | |
| ? 'Please either choose `select` or `include`.' | |
| : T extends SelectAndOmit | |
| ? 'Please either choose `select` or `omit`.' | |
| : {}) | |
| /** | |
| * Subset + Intersection | |
| * @desc From `T` pick properties that exist in `U` and intersect `K` | |
| */ | |
| export type SubsetIntersection<T, U, K> = { | |
| [key in keyof T]: key extends keyof U ? T[key] : never | |
| } & | |
| K | |
| type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }; | |
| /** | |
| * XOR is needed to have a real mutually exclusive union type | |
| * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types | |
| */ | |
| export type XOR<T, U> = | |
| T extends object ? | |
| U extends object ? | |
| (Without<T, U> & U) | (Without<U, T> & T) | |
| : U : T | |
| /** | |
| * Is T a Record? | |
| */ | |
| type IsObject<T extends any> = T extends Array<any> | |
| ? False | |
| : T extends Date | |
| ? False | |
| : T extends Uint8Array | |
| ? False | |
| : T extends BigInt | |
| ? False | |
| : T extends object | |
| ? True | |
| : False | |
| /** | |
| * If it's T[], return T | |
| */ | |
| export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T | |
| /** | |
| * From ts-toolbelt | |
| */ | |
| type __Either<O extends object, K extends Key> = Omit<O, K> & | |
| { | |
| // Merge all but K | |
| [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities | |
| }[K] | |
| type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>> | |
| type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>> | |
| type _Either< | |
| O extends object, | |
| K extends Key, | |
| strict extends Boolean | |
| > = { | |
| 1: EitherStrict<O, K> | |
| 0: EitherLoose<O, K> | |
| }[strict] | |
| export type Either< | |
| O extends object, | |
| K extends Key, | |
| strict extends Boolean = 1 | |
| > = O extends unknown ? _Either<O, K, strict> : never | |
| export type Union = any | |
| export type PatchUndefined<O extends object, O1 extends object> = { | |
| [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K] | |
| } & {} | |
| /** Helper Types for "Merge" **/ | |
| export type IntersectOf<U extends Union> = ( | |
| U extends unknown ? (k: U) => void : never | |
| ) extends (k: infer I) => void | |
| ? I | |
| : never | |
| export type Overwrite<O extends object, O1 extends object> = { | |
| [K in keyof O]: K extends keyof O1 ? O1[K] : O[K]; | |
| } & {}; | |
| type _Merge<U extends object> = IntersectOf<Overwrite<U, { | |
| [K in keyof U]-?: At<U, K>; | |
| }>>; | |
| type Key = string | number | symbol; | |
| type AtStrict<O extends object, K extends Key> = O[K & keyof O]; | |
| type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never; | |
| export type At<O extends object, K extends Key, strict extends Boolean = 1> = { | |
| 1: AtStrict<O, K>; | |
| 0: AtLoose<O, K>; | |
| }[strict]; | |
| export type ComputeRaw<A extends any> = A extends Function ? A : { | |
| [K in keyof A]: A[K]; | |
| } & {}; | |
| export type OptionalFlat<O> = { | |
| [K in keyof O]?: O[K]; | |
| } & {}; | |
| type _Record<K extends keyof any, T> = { | |
| [P in K]: T; | |
| }; | |
| // cause typescript not to expand types and preserve names | |
| type NoExpand<T> = T extends unknown ? T : never; | |
| // this type assumes the passed object is entirely optional | |
| export type AtLeast<O extends object, K extends string> = NoExpand< | |
| O extends unknown | |
| ? | (K extends keyof O ? { [P in K]: O[P] } & O : O) | |
| | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O | |
| : never>; | |
| type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never; | |
| export type Strict<U extends object> = ComputeRaw<_Strict<U>>; | |
| /** End Helper Types for "Merge" **/ | |
| export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>; | |
| export type Boolean = True | False | |
| export type True = 1 | |
| export type False = 0 | |
| export type Not<B extends Boolean> = { | |
| 0: 1 | |
| 1: 0 | |
| }[B] | |
| export type Extends<A1 extends any, A2 extends any> = [A1] extends [never] | |
| ? 0 // anything `never` is false | |
| : A1 extends A2 | |
| ? 1 | |
| : 0 | |
| export type Has<U extends Union, U1 extends Union> = Not< | |
| Extends<Exclude<U1, U>, U1> | |
| > | |
| export type Or<B1 extends Boolean, B2 extends Boolean> = { | |
| 0: { | |
| 0: 0 | |
| 1: 1 | |
| } | |
| 1: { | |
| 0: 1 | |
| 1: 1 | |
| } | |
| }[B1][B2] | |
| export type Keys<U extends Union> = U extends unknown ? keyof U : never | |
| export type GetScalarType<T, O> = O extends object ? { | |
| [P in keyof T]: P extends keyof O | |
| ? O[P] | |
| : never | |
| } : never | |
| type FieldPaths< | |
| T, | |
| U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'> | |
| > = IsObject<T> extends True ? U : T | |
| export type GetHavingFields<T> = { | |
| [K in keyof T]: Or< | |
| Or<Extends<'OR', K>, Extends<'AND', K>>, | |
| Extends<'NOT', K> | |
| > extends True | |
| ? // infer is only needed to not hit TS limit | |
| // based on the brilliant idea of Pierre-Antoine Mills | |
| // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437 | |
| T[K] extends infer TK | |
| ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never> | |
| : never | |
| : {} extends FieldPaths<T[K]> | |
| ? never | |
| : K | |
| }[keyof T] | |
| /** | |
| * Convert tuple to union | |
| */ | |
| type _TupleToUnion<T> = T extends (infer E)[] ? E : never | |
| type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K> | |
| export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T | |
| /** | |
| * Like `Pick`, but additionally can also accept an array of keys | |
| */ | |
| export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>> | |
| /** | |
| * Exclude all keys with underscores | |
| */ | |
| export type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T | |
| export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType> | |
| type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType> | |
| export const ModelName = { | |
| User: 'User', | |
| Session: 'Session', | |
| Dashboard: 'Dashboard', | |
| Widget: 'Widget', | |
| WidgetLog: 'WidgetLog' | |
| } as const | |
| export type ModelName = (typeof ModelName)[keyof typeof ModelName] | |
| export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> { | |
| returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions> | |
| } | |
| export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = { | |
| globalOmitOptions: { | |
| omit: GlobalOmitOptions | |
| } | |
| meta: { | |
| modelProps: "user" | "session" | "dashboard" | "widget" | "widgetLog" | |
| txIsolationLevel: TransactionIsolationLevel | |
| } | |
| model: { | |
| User: { | |
| payload: Prisma.$UserPayload<ExtArgs> | |
| fields: Prisma.UserFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.UserFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.UserFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.UserFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| findMany: { | |
| args: Prisma.UserFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| create: { | |
| args: Prisma.UserCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| createMany: { | |
| args: Prisma.UserCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.UserCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.UserDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| update: { | |
| args: Prisma.UserUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.UserDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.UserUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.UserUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.UserAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateUser> | |
| } | |
| groupBy: { | |
| args: Prisma.UserGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.UserCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Session: { | |
| payload: Prisma.$SessionPayload<ExtArgs> | |
| fields: Prisma.SessionFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.SessionFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.SessionFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| findMany: { | |
| args: Prisma.SessionFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| create: { | |
| args: Prisma.SessionCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| createMany: { | |
| args: Prisma.SessionCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.SessionDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| update: { | |
| args: Prisma.SessionUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.SessionDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.SessionUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.SessionUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.SessionAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateSession> | |
| } | |
| groupBy: { | |
| args: Prisma.SessionGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.SessionGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.SessionCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.SessionCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Dashboard: { | |
| payload: Prisma.$DashboardPayload<ExtArgs> | |
| fields: Prisma.DashboardFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.DashboardFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.DashboardFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.DashboardFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.DashboardFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| findMany: { | |
| args: Prisma.DashboardFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| create: { | |
| args: Prisma.DashboardCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| createMany: { | |
| args: Prisma.DashboardCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.DashboardCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.DashboardDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| update: { | |
| args: Prisma.DashboardUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.DashboardDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.DashboardUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.DashboardUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.DashboardUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$DashboardPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.DashboardAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateDashboard> | |
| } | |
| groupBy: { | |
| args: Prisma.DashboardGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.DashboardGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.DashboardCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.DashboardCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| Widget: { | |
| payload: Prisma.$WidgetPayload<ExtArgs> | |
| fields: Prisma.WidgetFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.WidgetFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.WidgetFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.WidgetFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.WidgetFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| findMany: { | |
| args: Prisma.WidgetFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| create: { | |
| args: Prisma.WidgetCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| createMany: { | |
| args: Prisma.WidgetCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.WidgetCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.WidgetDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| update: { | |
| args: Prisma.WidgetUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.WidgetDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.WidgetUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.WidgetUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.WidgetUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.WidgetAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateWidget> | |
| } | |
| groupBy: { | |
| args: Prisma.WidgetGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.WidgetCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| WidgetLog: { | |
| payload: Prisma.$WidgetLogPayload<ExtArgs> | |
| fields: Prisma.WidgetLogFieldRefs | |
| operations: { | |
| findUnique: { | |
| args: Prisma.WidgetLogFindUniqueArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | null | |
| } | |
| findUniqueOrThrow: { | |
| args: Prisma.WidgetLogFindUniqueOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| findFirst: { | |
| args: Prisma.WidgetLogFindFirstArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | null | |
| } | |
| findFirstOrThrow: { | |
| args: Prisma.WidgetLogFindFirstOrThrowArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| findMany: { | |
| args: Prisma.WidgetLogFindManyArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| create: { | |
| args: Prisma.WidgetLogCreateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| createMany: { | |
| args: Prisma.WidgetLogCreateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| createManyAndReturn: { | |
| args: Prisma.WidgetLogCreateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| delete: { | |
| args: Prisma.WidgetLogDeleteArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| update: { | |
| args: Prisma.WidgetLogUpdateArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| deleteMany: { | |
| args: Prisma.WidgetLogDeleteManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateMany: { | |
| args: Prisma.WidgetLogUpdateManyArgs<ExtArgs> | |
| result: BatchPayload | |
| } | |
| updateManyAndReturn: { | |
| args: Prisma.WidgetLogUpdateManyAndReturnArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload>[] | |
| } | |
| upsert: { | |
| args: Prisma.WidgetLogUpsertArgs<ExtArgs> | |
| result: runtime.Types.Utils.PayloadToResult<Prisma.$WidgetLogPayload> | |
| } | |
| aggregate: { | |
| args: Prisma.WidgetLogAggregateArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.AggregateWidgetLog> | |
| } | |
| groupBy: { | |
| args: Prisma.WidgetLogGroupByArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetLogGroupByOutputType>[] | |
| } | |
| count: { | |
| args: Prisma.WidgetLogCountArgs<ExtArgs> | |
| result: runtime.Types.Utils.Optional<Prisma.WidgetLogCountAggregateOutputType> | number | |
| } | |
| } | |
| } | |
| } | |
| } & { | |
| other: { | |
| payload: any | |
| operations: { | |
| $executeRaw: { | |
| args: [query: TemplateStringsArray | Sql, ...values: any[]], | |
| result: any | |
| } | |
| $executeRawUnsafe: { | |
| args: [query: string, ...values: any[]], | |
| result: any | |
| } | |
| $queryRaw: { | |
| args: [query: TemplateStringsArray | Sql, ...values: any[]], | |
| result: any | |
| } | |
| $queryRawUnsafe: { | |
| args: [query: string, ...values: any[]], | |
| result: any | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Enums | |
| */ | |
| export const TransactionIsolationLevel = runtime.makeStrictEnum({ | |
| ReadUncommitted: 'ReadUncommitted', | |
| ReadCommitted: 'ReadCommitted', | |
| RepeatableRead: 'RepeatableRead', | |
| Serializable: 'Serializable' | |
| } as const) | |
| export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] | |
| export const UserScalarFieldEnum = { | |
| id: 'id', | |
| anonymousId: 'anonymousId', | |
| telegramUserId: 'telegramUserId', | |
| telegramUserData: 'telegramUserData', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt' | |
| } as const | |
| export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum] | |
| export const SessionScalarFieldEnum = { | |
| id: 'id', | |
| userId: 'userId', | |
| createdAt: 'createdAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum] | |
| export const DashboardScalarFieldEnum = { | |
| id: 'id', | |
| name: 'name', | |
| deviceId: 'deviceId', | |
| userId: 'userId', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type DashboardScalarFieldEnum = (typeof DashboardScalarFieldEnum)[keyof typeof DashboardScalarFieldEnum] | |
| export const WidgetScalarFieldEnum = { | |
| id: 'id', | |
| options: 'options', | |
| state: 'state', | |
| columnIndex: 'columnIndex', | |
| rowIndex: 'rowIndex', | |
| columnCount: 'columnCount', | |
| rowCount: 'rowCount', | |
| isBlackTheme: 'isBlackTheme', | |
| backgroundColor: 'backgroundColor', | |
| primaryColor: 'primaryColor', | |
| positiveColor: 'positiveColor', | |
| negativeColor: 'negativeColor', | |
| dashboardId: 'dashboardId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetScalarFieldEnum = (typeof WidgetScalarFieldEnum)[keyof typeof WidgetScalarFieldEnum] | |
| export const WidgetLogScalarFieldEnum = { | |
| id: 'id', | |
| oldOptions: 'oldOptions', | |
| newOptions: 'newOptions', | |
| oldState: 'oldState', | |
| newState: 'newState', | |
| widgetId: 'widgetId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetLogScalarFieldEnum = (typeof WidgetLogScalarFieldEnum)[keyof typeof WidgetLogScalarFieldEnum] | |
| export const SortOrder = { | |
| asc: 'asc', | |
| desc: 'desc' | |
| } as const | |
| export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] | |
| export const NullableJsonNullValueInput = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull | |
| } as const | |
| export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput] | |
| export const QueryMode = { | |
| default: 'default', | |
| insensitive: 'insensitive' | |
| } as const | |
| export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode] | |
| export const JsonNullValueFilter = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull, | |
| AnyNull: AnyNull | |
| } as const | |
| export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter] | |
| export const NullsOrder = { | |
| first: 'first', | |
| last: 'last' | |
| } as const | |
| export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder] | |
| /** | |
| * Field references | |
| */ | |
| /** | |
| * Reference to a field of type 'String' | |
| */ | |
| export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'> | |
| /** | |
| * Reference to a field of type 'String[]' | |
| */ | |
| export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'> | |
| /** | |
| * Reference to a field of type 'Json' | |
| */ | |
| export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'> | |
| /** | |
| * Reference to a field of type 'QueryMode' | |
| */ | |
| export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'> | |
| /** | |
| * Reference to a field of type 'Boolean' | |
| */ | |
| export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'> | |
| /** | |
| * Reference to a field of type 'DateTime' | |
| */ | |
| export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'> | |
| /** | |
| * Reference to a field of type 'DateTime[]' | |
| */ | |
| export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'> | |
| /** | |
| * Reference to a field of type 'Int' | |
| */ | |
| export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'> | |
| /** | |
| * Reference to a field of type 'Int[]' | |
| */ | |
| export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'> | |
| /** | |
| * Reference to a field of type 'Float' | |
| */ | |
| export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'> | |
| /** | |
| * Reference to a field of type 'Float[]' | |
| */ | |
| export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'> | |
| /** | |
| * Batch Payload for updateMany & deleteMany & createMany | |
| */ | |
| export type BatchPayload = { | |
| count: number | |
| } | |
| export type Datasource = { | |
| url?: string | |
| } | |
| export type Datasources = { | |
| db?: Datasource | |
| } | |
| export const defineExtension = runtime.Extensions.defineExtension as unknown as runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs> | |
| export type DefaultPrismaClient = PrismaClient | |
| export type ErrorFormat = 'pretty' | 'colorless' | 'minimal' | |
| export interface PrismaClientOptions { | |
| /** | |
| * Overwrites the datasource url from your schema.prisma file | |
| */ | |
| datasources?: Datasources | |
| /** | |
| * Overwrites the datasource url from your schema.prisma file | |
| */ | |
| datasourceUrl?: string | |
| /** | |
| * @default "colorless" | |
| */ | |
| errorFormat?: ErrorFormat | |
| /** | |
| * @example | |
| * ``` | |
| * // Shorthand for `emit: 'stdout'` | |
| * log: ['query', 'info', 'warn', 'error'] | |
| * | |
| * // Emit as events only | |
| * log: [ | |
| * { emit: 'event', level: 'query' }, | |
| * { emit: 'event', level: 'info' }, | |
| * { emit: 'event', level: 'warn' } | |
| * { emit: 'event', level: 'error' } | |
| * ] | |
| * | |
| * / Emit as events and log to stdout | |
| * og: [ | |
| * { emit: 'stdout', level: 'query' }, | |
| * { emit: 'stdout', level: 'info' }, | |
| * { emit: 'stdout', level: 'warn' } | |
| * { emit: 'stdout', level: 'error' } | |
| * | |
| * ``` | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option). | |
| */ | |
| log?: (LogLevel | LogDefinition)[] | |
| /** | |
| * The default values for transactionOptions | |
| * maxWait ?= 2000 | |
| * timeout ?= 5000 | |
| */ | |
| transactionOptions?: { | |
| maxWait?: number | |
| timeout?: number | |
| isolationLevel?: TransactionIsolationLevel | |
| } | |
| /** | |
| * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale` | |
| */ | |
| adapter?: runtime.SqlDriverAdapterFactory | null | |
| /** | |
| * Global configuration for omitting model fields by default. | |
| * | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient({ | |
| * omit: { | |
| * user: { | |
| * password: true | |
| * } | |
| * } | |
| * }) | |
| * ``` | |
| */ | |
| omit?: GlobalOmitConfig | |
| } | |
| export type GlobalOmitConfig = { | |
| user?: Prisma.UserOmit | |
| session?: Prisma.SessionOmit | |
| dashboard?: Prisma.DashboardOmit | |
| widget?: Prisma.WidgetOmit | |
| widgetLog?: Prisma.WidgetLogOmit | |
| } | |
| /* Types for Logging */ | |
| export type LogLevel = 'info' | 'query' | 'warn' | 'error' | |
| export type LogDefinition = { | |
| level: LogLevel | |
| emit: 'stdout' | 'event' | |
| } | |
| export type CheckIsLogLevel<T> = T extends LogLevel ? T : never; | |
| export type GetLogType<T> = CheckIsLogLevel< | |
| T extends LogDefinition ? T['level'] : T | |
| >; | |
| export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition> | |
| ? GetLogType<T[number]> | |
| : never; | |
| export type QueryEvent = { | |
| timestamp: Date | |
| query: string | |
| params: string | |
| duration: number | |
| target: string | |
| } | |
| export type LogEvent = { | |
| timestamp: Date | |
| message: string | |
| target: string | |
| } | |
| /* End Types for Logging */ | |
| export type PrismaAction = | |
| | 'findUnique' | |
| | 'findUniqueOrThrow' | |
| | 'findMany' | |
| | 'findFirst' | |
| | 'findFirstOrThrow' | |
| | 'create' | |
| | 'createMany' | |
| | 'createManyAndReturn' | |
| | 'update' | |
| | 'updateMany' | |
| | 'updateManyAndReturn' | |
| | 'upsert' | |
| | 'delete' | |
| | 'deleteMany' | |
| | 'executeRaw' | |
| | 'queryRaw' | |
| | 'aggregate' | |
| | 'count' | |
| | 'runCommandRaw' | |
| | 'findRaw' | |
| | 'groupBy' | |
| /** | |
| * `PrismaClient` proxy available in interactive transactions. | |
| */ | |
| export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList> | |
| ```` | |
| ## File: web/src/server/generated/prisma/internal/prismaNamespaceBrowser.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * WARNING: This is an internal file that is subject to change! | |
| * | |
| * 🛑 Under no circumstances should you import this file directly! 🛑 | |
| * | |
| * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file. | |
| * While this enables partial backward compatibility, it is not part of the stable public API. | |
| * | |
| * If you are looking for your Models, Enums, and Input Types, please import them from the respective | |
| * model files in the `model` directory! | |
| */ | |
| import * as runtime from "@prisma/client/runtime/index-browser" | |
| export type * from '../models' | |
| export type * from './prismaNamespace' | |
| export const Decimal = runtime.Decimal | |
| export const NullTypes = { | |
| DbNull: runtime.objectEnumValues.classes.DbNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.DbNull), | |
| JsonNull: runtime.objectEnumValues.classes.JsonNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.JsonNull), | |
| AnyNull: runtime.objectEnumValues.classes.AnyNull as (new (secret: never) => typeof runtime.objectEnumValues.instances.AnyNull), | |
| } | |
| /** | |
| * Helper for filtering JSON entries that have `null` on the database (empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const DbNull = runtime.objectEnumValues.instances.DbNull | |
| /** | |
| * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const JsonNull = runtime.objectEnumValues.instances.JsonNull | |
| /** | |
| * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` | |
| * | |
| * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field | |
| */ | |
| export const AnyNull = runtime.objectEnumValues.instances.AnyNull | |
| export const ModelName = { | |
| User: 'User', | |
| Session: 'Session', | |
| Dashboard: 'Dashboard', | |
| Widget: 'Widget', | |
| WidgetLog: 'WidgetLog' | |
| } as const | |
| export type ModelName = (typeof ModelName)[keyof typeof ModelName] | |
| /* | |
| * Enums | |
| */ | |
| export const TransactionIsolationLevel = runtime.makeStrictEnum({ | |
| ReadUncommitted: 'ReadUncommitted', | |
| ReadCommitted: 'ReadCommitted', | |
| RepeatableRead: 'RepeatableRead', | |
| Serializable: 'Serializable' | |
| } as const) | |
| export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] | |
| export const UserScalarFieldEnum = { | |
| id: 'id', | |
| anonymousId: 'anonymousId', | |
| telegramUserId: 'telegramUserId', | |
| telegramUserData: 'telegramUserData', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt' | |
| } as const | |
| export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum] | |
| export const SessionScalarFieldEnum = { | |
| id: 'id', | |
| userId: 'userId', | |
| createdAt: 'createdAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum] | |
| export const DashboardScalarFieldEnum = { | |
| id: 'id', | |
| name: 'name', | |
| deviceId: 'deviceId', | |
| userId: 'userId', | |
| isBlackTheme: 'isBlackTheme', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type DashboardScalarFieldEnum = (typeof DashboardScalarFieldEnum)[keyof typeof DashboardScalarFieldEnum] | |
| export const WidgetScalarFieldEnum = { | |
| id: 'id', | |
| options: 'options', | |
| state: 'state', | |
| columnIndex: 'columnIndex', | |
| rowIndex: 'rowIndex', | |
| columnCount: 'columnCount', | |
| rowCount: 'rowCount', | |
| isBlackTheme: 'isBlackTheme', | |
| backgroundColor: 'backgroundColor', | |
| primaryColor: 'primaryColor', | |
| positiveColor: 'positiveColor', | |
| negativeColor: 'negativeColor', | |
| dashboardId: 'dashboardId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetScalarFieldEnum = (typeof WidgetScalarFieldEnum)[keyof typeof WidgetScalarFieldEnum] | |
| export const WidgetLogScalarFieldEnum = { | |
| id: 'id', | |
| oldOptions: 'oldOptions', | |
| newOptions: 'newOptions', | |
| oldState: 'oldState', | |
| newState: 'newState', | |
| widgetId: 'widgetId', | |
| createdAt: 'createdAt', | |
| updatedAt: 'updatedAt', | |
| deletedAt: 'deletedAt' | |
| } as const | |
| export type WidgetLogScalarFieldEnum = (typeof WidgetLogScalarFieldEnum)[keyof typeof WidgetLogScalarFieldEnum] | |
| export const SortOrder = { | |
| asc: 'asc', | |
| desc: 'desc' | |
| } as const | |
| export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] | |
| export const NullableJsonNullValueInput = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull | |
| } as const | |
| export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput] | |
| export const QueryMode = { | |
| default: 'default', | |
| insensitive: 'insensitive' | |
| } as const | |
| export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode] | |
| export const JsonNullValueFilter = { | |
| DbNull: DbNull, | |
| JsonNull: JsonNull, | |
| AnyNull: AnyNull | |
| } as const | |
| export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter] | |
| export const NullsOrder = { | |
| first: 'first', | |
| last: 'last' | |
| } as const | |
| export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder] | |
| ```` | |
| ## File: web/src/server/generated/prisma/models/Dashboard.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Dashboard` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type DashboardModel = runtime.Types.Result.DefaultSelection<Prisma.$DashboardPayload> | |
| export type AggregateDashboard = { | |
| _count: DashboardCountAggregateOutputType | null | |
| _min: DashboardMinAggregateOutputType | null | |
| _max: DashboardMaxAggregateOutputType | null | |
| } | |
| export type DashboardMinAggregateOutputType = { | |
| id: string | null | |
| name: string | null | |
| deviceId: string | null | |
| userId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type DashboardMaxAggregateOutputType = { | |
| id: string | null | |
| name: string | null | |
| deviceId: string | null | |
| userId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type DashboardCountAggregateOutputType = { | |
| id: number | |
| name: number | |
| deviceId: number | |
| userId: number | |
| isBlackTheme: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type DashboardMinAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type DashboardMaxAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type DashboardCountAggregateInputType = { | |
| id?: true | |
| name?: true | |
| deviceId?: true | |
| userId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type DashboardAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Dashboard to aggregate. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Dashboards | |
| **/ | |
| _count?: true | DashboardCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: DashboardMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: DashboardMaxAggregateInputType | |
| } | |
| export type GetDashboardAggregateType<T extends DashboardAggregateArgs> = { | |
| [P in keyof T & keyof AggregateDashboard]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateDashboard[P]> | |
| : Prisma.GetScalarType<T[P], AggregateDashboard[P]> | |
| } | |
| export type DashboardGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.DashboardWhereInput | |
| orderBy?: Prisma.DashboardOrderByWithAggregationInput | Prisma.DashboardOrderByWithAggregationInput[] | |
| by: Prisma.DashboardScalarFieldEnum[] | Prisma.DashboardScalarFieldEnum | |
| having?: Prisma.DashboardScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: DashboardCountAggregateInputType | true | |
| _min?: DashboardMinAggregateInputType | |
| _max?: DashboardMaxAggregateInputType | |
| } | |
| export type DashboardGroupByOutputType = { | |
| id: string | |
| name: string | |
| deviceId: string | null | |
| userId: string | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: DashboardCountAggregateOutputType | null | |
| _min: DashboardMinAggregateOutputType | null | |
| _max: DashboardMaxAggregateOutputType | null | |
| } | |
| type GetDashboardGroupByPayload<T extends DashboardGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<DashboardGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof DashboardGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], DashboardGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], DashboardGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type DashboardWhereInput = { | |
| AND?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| OR?: Prisma.DashboardWhereInput[] | |
| NOT?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| id?: Prisma.UuidFilter<"Dashboard"> | string | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| Widget?: Prisma.WidgetListRelationFilter | |
| } | |
| export type DashboardOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| User?: Prisma.UserOrderByWithRelationInput | |
| Widget?: Prisma.WidgetOrderByRelationAggregateInput | |
| } | |
| export type DashboardWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| deviceId?: string | |
| userId_name?: Prisma.DashboardUserIdNameCompoundUniqueInput | |
| AND?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| OR?: Prisma.DashboardWhereInput[] | |
| NOT?: Prisma.DashboardWhereInput | Prisma.DashboardWhereInput[] | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| Widget?: Prisma.WidgetListRelationFilter | |
| }, "id" | "userId_name" | "deviceId"> | |
| export type DashboardOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.DashboardCountOrderByAggregateInput | |
| _max?: Prisma.DashboardMaxOrderByAggregateInput | |
| _min?: Prisma.DashboardMinOrderByAggregateInput | |
| } | |
| export type DashboardScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.DashboardScalarWhereWithAggregatesInput | Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.DashboardScalarWhereWithAggregatesInput | Prisma.DashboardScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Dashboard"> | string | |
| name?: Prisma.StringWithAggregatesFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableWithAggregatesFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidWithAggregatesFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Dashboard"> | Date | string | null | |
| } | |
| export type DashboardCreateInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutDashboardInput | |
| Widget?: Prisma.WidgetCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetUncheckedCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutDashboardNestedInput | |
| Widget?: Prisma.WidgetUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUncheckedUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardCreateManyInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardListRelationFilter = { | |
| every?: Prisma.DashboardWhereInput | |
| some?: Prisma.DashboardWhereInput | |
| none?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type DashboardUserIdNameCompoundUniqueInput = { | |
| userId: string | |
| name: string | |
| } | |
| export type DashboardCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| name?: Prisma.SortOrder | |
| deviceId?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type DashboardScalarRelationFilter = { | |
| is?: Prisma.DashboardWhereInput | |
| isNot?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| } | |
| export type DashboardUncheckedCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| } | |
| export type DashboardUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput | Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| set?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| disconnect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| delete?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| update?: Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput | Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.DashboardUpdateManyWithWhereWithoutUserInput | Prisma.DashboardUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| } | |
| export type DashboardUncheckedUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | Prisma.DashboardCreateWithoutUserInput[] | Prisma.DashboardUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutUserInput | Prisma.DashboardCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput | Prisma.DashboardUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.DashboardCreateManyUserInputEnvelope | |
| set?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| disconnect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| delete?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| connect?: Prisma.DashboardWhereUniqueInput | Prisma.DashboardWhereUniqueInput[] | |
| update?: Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput | Prisma.DashboardUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.DashboardUpdateManyWithWhereWithoutUserInput | Prisma.DashboardUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| } | |
| export type DashboardCreateNestedOneWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutWidgetInput | |
| connect?: Prisma.DashboardWhereUniqueInput | |
| } | |
| export type DashboardUpdateOneRequiredWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| connectOrCreate?: Prisma.DashboardCreateOrConnectWithoutWidgetInput | |
| upsert?: Prisma.DashboardUpsertWithoutWidgetInput | |
| connect?: Prisma.DashboardWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.DashboardUpdateToOneWithWhereWithoutWidgetInput, Prisma.DashboardUpdateWithoutWidgetInput>, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type DashboardCreateWithoutUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateWithoutUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget?: Prisma.WidgetUncheckedCreateNestedManyWithoutDashboardInput | |
| } | |
| export type DashboardCreateOrConnectWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | |
| } | |
| export type DashboardCreateManyUserInputEnvelope = { | |
| data: Prisma.DashboardCreateManyUserInput | Prisma.DashboardCreateManyUserInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type DashboardUpsertWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| update: Prisma.XOR<Prisma.DashboardUpdateWithoutUserInput, Prisma.DashboardUncheckedUpdateWithoutUserInput> | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutUserInput, Prisma.DashboardUncheckedCreateWithoutUserInput> | |
| } | |
| export type DashboardUpdateWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateWithoutUserInput, Prisma.DashboardUncheckedUpdateWithoutUserInput> | |
| } | |
| export type DashboardUpdateManyWithWhereWithoutUserInput = { | |
| where: Prisma.DashboardScalarWhereInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyWithoutUserInput> | |
| } | |
| export type DashboardScalarWhereInput = { | |
| AND?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| OR?: Prisma.DashboardScalarWhereInput[] | |
| NOT?: Prisma.DashboardScalarWhereInput | Prisma.DashboardScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Dashboard"> | string | |
| name?: Prisma.StringFilter<"Dashboard"> | string | |
| deviceId?: Prisma.StringNullableFilter<"Dashboard"> | string | null | |
| userId?: Prisma.UuidFilter<"Dashboard"> | string | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Dashboard"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Dashboard"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Dashboard"> | Date | string | null | |
| } | |
| export type DashboardCreateWithoutWidgetInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutDashboardInput | |
| } | |
| export type DashboardUncheckedCreateWithoutWidgetInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| userId: string | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardCreateOrConnectWithoutWidgetInput = { | |
| where: Prisma.DashboardWhereUniqueInput | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type DashboardUpsertWithoutWidgetInput = { | |
| update: Prisma.XOR<Prisma.DashboardUpdateWithoutWidgetInput, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| create: Prisma.XOR<Prisma.DashboardCreateWithoutWidgetInput, Prisma.DashboardUncheckedCreateWithoutWidgetInput> | |
| where?: Prisma.DashboardWhereInput | |
| } | |
| export type DashboardUpdateToOneWithWhereWithoutWidgetInput = { | |
| where?: Prisma.DashboardWhereInput | |
| data: Prisma.XOR<Prisma.DashboardUpdateWithoutWidgetInput, Prisma.DashboardUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type DashboardUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type DashboardCreateManyUserInput = { | |
| id?: string | |
| name: string | |
| deviceId?: string | null | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type DashboardUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUncheckedUpdateManyWithoutDashboardNestedInput | |
| } | |
| export type DashboardUncheckedUpdateManyWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| name?: Prisma.StringFieldUpdateOperationsInput | string | |
| deviceId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| /** | |
| * Count Type DashboardCountOutputType | |
| */ | |
| export type DashboardCountOutputType = { | |
| Widget: number | |
| } | |
| export type DashboardCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | DashboardCountOutputTypeCountWidgetArgs | |
| } | |
| /** | |
| * DashboardCountOutputType without action | |
| */ | |
| export type DashboardCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the DashboardCountOutputType | |
| */ | |
| select?: Prisma.DashboardCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * DashboardCountOutputType without action | |
| */ | |
| export type DashboardCountOutputTypeCountWidgetArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetWhereInput | |
| } | |
| export type DashboardSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| Widget?: boolean | Prisma.Dashboard$WidgetArgs<ExtArgs> | |
| _count?: boolean | Prisma.DashboardCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["dashboard"]> | |
| export type DashboardSelectScalar = { | |
| id?: boolean | |
| name?: boolean | |
| deviceId?: boolean | |
| userId?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type DashboardOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "name" | "deviceId" | "userId" | "isBlackTheme" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["dashboard"]> | |
| export type DashboardInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| Widget?: boolean | Prisma.Dashboard$WidgetArgs<ExtArgs> | |
| _count?: boolean | Prisma.DashboardCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type DashboardIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type DashboardIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type $DashboardPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Dashboard" | |
| objects: { | |
| User: Prisma.$UserPayload<ExtArgs> | |
| Widget: Prisma.$WidgetPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| name: string | |
| deviceId: string | null | |
| userId: string | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["dashboard"]> | |
| composites: {} | |
| } | |
| export type DashboardGetPayload<S extends boolean | null | undefined | DashboardDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$DashboardPayload, S> | |
| export type DashboardCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<DashboardFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: DashboardCountAggregateInputType | true | |
| } | |
| export interface DashboardDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Dashboard'], meta: { name: 'Dashboard' } } | |
| /** | |
| * Find zero or one Dashboard that matches the filter. | |
| * @param {DashboardFindUniqueArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends DashboardFindUniqueArgs>(args: Prisma.SelectSubset<T, DashboardFindUniqueArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Dashboard that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {DashboardFindUniqueOrThrowArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends DashboardFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, DashboardFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Dashboard that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindFirstArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends DashboardFindFirstArgs>(args?: Prisma.SelectSubset<T, DashboardFindFirstArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Dashboard that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindFirstOrThrowArgs} args - Arguments to find a Dashboard | |
| * @example | |
| * // Get one Dashboard | |
| * const dashboard = await prisma.dashboard.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends DashboardFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, DashboardFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Dashboards that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Dashboards | |
| * const dashboards = await prisma.dashboard.findMany() | |
| * | |
| * // Get first 10 Dashboards | |
| * const dashboards = await prisma.dashboard.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends DashboardFindManyArgs>(args?: Prisma.SelectSubset<T, DashboardFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Dashboard. | |
| * @param {DashboardCreateArgs} args - Arguments to create a Dashboard. | |
| * @example | |
| * // Create one Dashboard | |
| * const Dashboard = await prisma.dashboard.create({ | |
| * data: { | |
| * // ... data to create a Dashboard | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends DashboardCreateArgs>(args: Prisma.SelectSubset<T, DashboardCreateArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Dashboards. | |
| * @param {DashboardCreateManyArgs} args - Arguments to create many Dashboards. | |
| * @example | |
| * // Create many Dashboards | |
| * const dashboard = await prisma.dashboard.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends DashboardCreateManyArgs>(args?: Prisma.SelectSubset<T, DashboardCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Dashboards and returns the data saved in the database. | |
| * @param {DashboardCreateManyAndReturnArgs} args - Arguments to create many Dashboards. | |
| * @example | |
| * // Create many Dashboards | |
| * const dashboard = await prisma.dashboard.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Dashboards and only return the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends DashboardCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, DashboardCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Dashboard. | |
| * @param {DashboardDeleteArgs} args - Arguments to delete one Dashboard. | |
| * @example | |
| * // Delete one Dashboard | |
| * const Dashboard = await prisma.dashboard.delete({ | |
| * where: { | |
| * // ... filter to delete one Dashboard | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends DashboardDeleteArgs>(args: Prisma.SelectSubset<T, DashboardDeleteArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Dashboard. | |
| * @param {DashboardUpdateArgs} args - Arguments to update one Dashboard. | |
| * @example | |
| * // Update one Dashboard | |
| * const dashboard = await prisma.dashboard.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends DashboardUpdateArgs>(args: Prisma.SelectSubset<T, DashboardUpdateArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Dashboards. | |
| * @param {DashboardDeleteManyArgs} args - Arguments to filter Dashboards to delete. | |
| * @example | |
| * // Delete a few Dashboards | |
| * const { count } = await prisma.dashboard.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends DashboardDeleteManyArgs>(args?: Prisma.SelectSubset<T, DashboardDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Dashboards. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Dashboards | |
| * const dashboard = await prisma.dashboard.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends DashboardUpdateManyArgs>(args: Prisma.SelectSubset<T, DashboardUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Dashboards and returns the data updated in the database. | |
| * @param {DashboardUpdateManyAndReturnArgs} args - Arguments to update many Dashboards. | |
| * @example | |
| * // Update many Dashboards | |
| * const dashboard = await prisma.dashboard.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Dashboards and only return the `id` | |
| * const dashboardWithIdOnly = await prisma.dashboard.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends DashboardUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, DashboardUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Dashboard. | |
| * @param {DashboardUpsertArgs} args - Arguments to update or create a Dashboard. | |
| * @example | |
| * // Update or create a Dashboard | |
| * const dashboard = await prisma.dashboard.upsert({ | |
| * create: { | |
| * // ... data to create a Dashboard | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Dashboard we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends DashboardUpsertArgs>(args: Prisma.SelectSubset<T, DashboardUpsertArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Dashboards. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardCountArgs} args - Arguments to filter Dashboards to count. | |
| * @example | |
| * // Count the number of Dashboards | |
| * const count = await prisma.dashboard.count({ | |
| * where: { | |
| * // ... the filter for the Dashboards we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends DashboardCountArgs>( | |
| args?: Prisma.Subset<T, DashboardCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], DashboardCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Dashboard. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends DashboardAggregateArgs>(args: Prisma.Subset<T, DashboardAggregateArgs>): Prisma.PrismaPromise<GetDashboardAggregateType<T>> | |
| /** | |
| * Group by Dashboard. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {DashboardGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends DashboardGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: DashboardGroupByArgs['orderBy'] } | |
| : { orderBy?: DashboardGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, DashboardGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDashboardGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Dashboard model | |
| */ | |
| readonly fields: DashboardFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Dashboard. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__DashboardClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| User<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| Widget<T extends Prisma.Dashboard$WidgetArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Dashboard$WidgetArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Dashboard model | |
| */ | |
| export interface DashboardFieldRefs { | |
| readonly id: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly name: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly deviceId: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly userId: Prisma.FieldRef<"Dashboard", 'String'> | |
| readonly isBlackTheme: Prisma.FieldRef<"Dashboard", 'Boolean'> | |
| readonly createdAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Dashboard", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Dashboard findUnique | |
| */ | |
| export type DashboardFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard findUniqueOrThrow | |
| */ | |
| export type DashboardFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard findFirst | |
| */ | |
| export type DashboardFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Dashboards. | |
| */ | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard findFirstOrThrow | |
| */ | |
| export type DashboardFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboard to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Dashboards. | |
| */ | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard findMany | |
| */ | |
| export type DashboardFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Dashboards to fetch. | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Dashboards to fetch. | |
| */ | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Dashboards. | |
| */ | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Dashboards from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Dashboards. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard create | |
| */ | |
| export type DashboardCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Dashboard. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardCreateInput, Prisma.DashboardUncheckedCreateInput> | |
| } | |
| /** | |
| * Dashboard createMany | |
| */ | |
| export type DashboardCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Dashboards. | |
| */ | |
| data: Prisma.DashboardCreateManyInput | Prisma.DashboardCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Dashboard createManyAndReturn | |
| */ | |
| export type DashboardCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Dashboards. | |
| */ | |
| data: Prisma.DashboardCreateManyInput | Prisma.DashboardCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Dashboard update | |
| */ | |
| export type DashboardUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Dashboard. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateInput, Prisma.DashboardUncheckedUpdateInput> | |
| /** | |
| * Choose, which Dashboard to update. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard updateMany | |
| */ | |
| export type DashboardUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Dashboards. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Dashboards to update | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Dashboard updateManyAndReturn | |
| */ | |
| export type DashboardUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Dashboards. | |
| */ | |
| data: Prisma.XOR<Prisma.DashboardUpdateManyMutationInput, Prisma.DashboardUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Dashboards to update | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Dashboard upsert | |
| */ | |
| export type DashboardUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Dashboard to update in case it exists. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| /** | |
| * In case the Dashboard found by the `where` argument doesn't exist, create a new Dashboard with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.DashboardCreateInput, Prisma.DashboardUncheckedCreateInput> | |
| /** | |
| * In case the Dashboard was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.DashboardUpdateInput, Prisma.DashboardUncheckedUpdateInput> | |
| } | |
| /** | |
| * Dashboard delete | |
| */ | |
| export type DashboardDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| /** | |
| * Filter which Dashboard to delete. | |
| */ | |
| where: Prisma.DashboardWhereUniqueInput | |
| } | |
| /** | |
| * Dashboard deleteMany | |
| */ | |
| export type DashboardDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Dashboards to delete | |
| */ | |
| where?: Prisma.DashboardWhereInput | |
| /** | |
| * Limit how many Dashboards to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Dashboard.Widget | |
| */ | |
| export type Dashboard$WidgetArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| where?: Prisma.WidgetWhereInput | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Dashboard without action | |
| */ | |
| export type DashboardDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/models/Session.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Session` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type SessionModel = runtime.Types.Result.DefaultSelection<Prisma.$SessionPayload> | |
| export type AggregateSession = { | |
| _count: SessionCountAggregateOutputType | null | |
| _min: SessionMinAggregateOutputType | null | |
| _max: SessionMaxAggregateOutputType | null | |
| } | |
| export type SessionMinAggregateOutputType = { | |
| id: string | null | |
| userId: string | null | |
| createdAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type SessionMaxAggregateOutputType = { | |
| id: string | null | |
| userId: string | null | |
| createdAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type SessionCountAggregateOutputType = { | |
| id: number | |
| userId: number | |
| createdAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type SessionMinAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| } | |
| export type SessionMaxAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| } | |
| export type SessionCountAggregateInputType = { | |
| id?: true | |
| userId?: true | |
| createdAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type SessionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Session to aggregate. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Sessions | |
| **/ | |
| _count?: true | SessionCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: SessionMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: SessionMaxAggregateInputType | |
| } | |
| export type GetSessionAggregateType<T extends SessionAggregateArgs> = { | |
| [P in keyof T & keyof AggregateSession]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateSession[P]> | |
| : Prisma.GetScalarType<T[P], AggregateSession[P]> | |
| } | |
| export type SessionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.SessionWhereInput | |
| orderBy?: Prisma.SessionOrderByWithAggregationInput | Prisma.SessionOrderByWithAggregationInput[] | |
| by: Prisma.SessionScalarFieldEnum[] | Prisma.SessionScalarFieldEnum | |
| having?: Prisma.SessionScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: SessionCountAggregateInputType | true | |
| _min?: SessionMinAggregateInputType | |
| _max?: SessionMaxAggregateInputType | |
| } | |
| export type SessionGroupByOutputType = { | |
| id: string | |
| userId: string | |
| createdAt: Date | |
| deletedAt: Date | null | |
| _count: SessionCountAggregateOutputType | null | |
| _min: SessionMinAggregateOutputType | null | |
| _max: SessionMaxAggregateOutputType | null | |
| } | |
| type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<SessionGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type SessionWhereInput = { | |
| AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| OR?: Prisma.SessionWhereInput[] | |
| NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| id?: Prisma.UuidFilter<"Session"> | string | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| } | |
| export type SessionOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| User?: Prisma.UserOrderByWithRelationInput | |
| } | |
| export type SessionWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| OR?: Prisma.SessionWhereInput[] | |
| NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[] | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| User?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput> | |
| }, "id"> | |
| export type SessionOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.SessionCountOrderByAggregateInput | |
| _max?: Prisma.SessionMaxOrderByAggregateInput | |
| _min?: Prisma.SessionMinOrderByAggregateInput | |
| } | |
| export type SessionScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.SessionScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Session"> | string | |
| userId?: Prisma.UuidWithAggregatesFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Session"> | Date | string | null | |
| } | |
| export type SessionCreateInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| User: Prisma.UserCreateNestedOneWithoutSessionInput | |
| } | |
| export type SessionUncheckedCreateInput = { | |
| id?: string | |
| userId: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| User?: Prisma.UserUpdateOneRequiredWithoutSessionNestedInput | |
| } | |
| export type SessionUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionCreateManyInput = { | |
| id?: string | |
| userId: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| userId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionListRelationFilter = { | |
| every?: Prisma.SessionWhereInput | |
| some?: Prisma.SessionWhereInput | |
| none?: Prisma.SessionWhereInput | |
| } | |
| export type SessionOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type SessionCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| userId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type SessionCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| } | |
| export type SessionUncheckedCreateNestedManyWithoutUserInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| } | |
| export type SessionUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| } | |
| export type SessionUncheckedUpdateManyWithoutUserNestedInput = { | |
| create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[] | |
| connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[] | |
| upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[] | |
| createMany?: Prisma.SessionCreateManyUserInputEnvelope | |
| set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[] | |
| update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[] | |
| updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[] | |
| deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| } | |
| export type NullableDateTimeFieldUpdateOperationsInput = { | |
| set?: Date | string | null | |
| } | |
| export type SessionCreateWithoutUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUncheckedCreateWithoutUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionCreateOrConnectWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | |
| } | |
| export type SessionCreateManyUserInputEnvelope = { | |
| data: Prisma.SessionCreateManyUserInput | Prisma.SessionCreateManyUserInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type SessionUpsertWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| update: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput> | |
| create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | |
| } | |
| export type SessionUpdateWithWhereUniqueWithoutUserInput = { | |
| where: Prisma.SessionWhereUniqueInput | |
| data: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput> | |
| } | |
| export type SessionUpdateManyWithWhereWithoutUserInput = { | |
| where: Prisma.SessionScalarWhereInput | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyWithoutUserInput> | |
| } | |
| export type SessionScalarWhereInput = { | |
| AND?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| OR?: Prisma.SessionScalarWhereInput[] | |
| NOT?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Session"> | string | |
| userId?: Prisma.UuidFilter<"Session"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Session"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Session"> | Date | string | null | |
| } | |
| export type SessionCreateManyUserInput = { | |
| id?: string | |
| createdAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type SessionUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionUncheckedUpdateManyWithoutUserInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type SessionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["session"]> | |
| export type SessionSelectScalar = { | |
| id?: boolean | |
| userId?: boolean | |
| createdAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type SessionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "userId" | "createdAt" | "deletedAt", ExtArgs["result"]["session"]> | |
| export type SessionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type SessionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type SessionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| User?: boolean | Prisma.UserDefaultArgs<ExtArgs> | |
| } | |
| export type $SessionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Session" | |
| objects: { | |
| User: Prisma.$UserPayload<ExtArgs> | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| userId: string | |
| createdAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["session"]> | |
| composites: {} | |
| } | |
| export type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$SessionPayload, S> | |
| export type SessionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: SessionCountAggregateInputType | true | |
| } | |
| export interface SessionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } } | |
| /** | |
| * Find zero or one Session that matches the filter. | |
| * @param {SessionFindUniqueArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends SessionFindUniqueArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Session that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Session that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindFirstArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends SessionFindFirstArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Session that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session | |
| * @example | |
| * // Get one Session | |
| * const session = await prisma.session.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Sessions that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Sessions | |
| * const sessions = await prisma.session.findMany() | |
| * | |
| * // Get first 10 Sessions | |
| * const sessions = await prisma.session.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends SessionFindManyArgs>(args?: Prisma.SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Session. | |
| * @param {SessionCreateArgs} args - Arguments to create a Session. | |
| * @example | |
| * // Create one Session | |
| * const Session = await prisma.session.create({ | |
| * data: { | |
| * // ... data to create a Session | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends SessionCreateArgs>(args: Prisma.SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Sessions. | |
| * @param {SessionCreateManyArgs} args - Arguments to create many Sessions. | |
| * @example | |
| * // Create many Sessions | |
| * const session = await prisma.session.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends SessionCreateManyArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Sessions and returns the data saved in the database. | |
| * @param {SessionCreateManyAndReturnArgs} args - Arguments to create many Sessions. | |
| * @example | |
| * // Create many Sessions | |
| * const session = await prisma.session.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Sessions and only return the `id` | |
| * const sessionWithIdOnly = await prisma.session.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends SessionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Session. | |
| * @param {SessionDeleteArgs} args - Arguments to delete one Session. | |
| * @example | |
| * // Delete one Session | |
| * const Session = await prisma.session.delete({ | |
| * where: { | |
| * // ... filter to delete one Session | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends SessionDeleteArgs>(args: Prisma.SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Session. | |
| * @param {SessionUpdateArgs} args - Arguments to update one Session. | |
| * @example | |
| * // Update one Session | |
| * const session = await prisma.session.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends SessionUpdateArgs>(args: Prisma.SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Sessions. | |
| * @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete. | |
| * @example | |
| * // Delete a few Sessions | |
| * const { count } = await prisma.session.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends SessionDeleteManyArgs>(args?: Prisma.SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Sessions. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Sessions | |
| * const session = await prisma.session.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends SessionUpdateManyArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Sessions and returns the data updated in the database. | |
| * @param {SessionUpdateManyAndReturnArgs} args - Arguments to update many Sessions. | |
| * @example | |
| * // Update many Sessions | |
| * const session = await prisma.session.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Sessions and only return the `id` | |
| * const sessionWithIdOnly = await prisma.session.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends SessionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Session. | |
| * @param {SessionUpsertArgs} args - Arguments to update or create a Session. | |
| * @example | |
| * // Update or create a Session | |
| * const session = await prisma.session.upsert({ | |
| * create: { | |
| * // ... data to create a Session | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Session we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends SessionUpsertArgs>(args: Prisma.SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Sessions. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionCountArgs} args - Arguments to filter Sessions to count. | |
| * @example | |
| * // Count the number of Sessions | |
| * const count = await prisma.session.count({ | |
| * where: { | |
| * // ... the filter for the Sessions we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends SessionCountArgs>( | |
| args?: Prisma.Subset<T, SessionCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], SessionCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Session. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends SessionAggregateArgs>(args: Prisma.Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>> | |
| /** | |
| * Group by Session. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {SessionGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends SessionGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: SessionGroupByArgs['orderBy'] } | |
| : { orderBy?: SessionGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Session model | |
| */ | |
| readonly fields: SessionFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Session. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__SessionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| User<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Session model | |
| */ | |
| export interface SessionFieldRefs { | |
| readonly id: Prisma.FieldRef<"Session", 'String'> | |
| readonly userId: Prisma.FieldRef<"Session", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"Session", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Session", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Session findUnique | |
| */ | |
| export type SessionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session findUniqueOrThrow | |
| */ | |
| export type SessionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session findFirst | |
| */ | |
| export type SessionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Sessions. | |
| */ | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session findFirstOrThrow | |
| */ | |
| export type SessionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Session to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Sessions. | |
| */ | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session findMany | |
| */ | |
| export type SessionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Sessions to fetch. | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Sessions to fetch. | |
| */ | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Sessions. | |
| */ | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Sessions from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Sessions. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * Session create | |
| */ | |
| export type SessionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Session. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput> | |
| } | |
| /** | |
| * Session createMany | |
| */ | |
| export type SessionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Sessions. | |
| */ | |
| data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Session createManyAndReturn | |
| */ | |
| export type SessionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Sessions. | |
| */ | |
| data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Session update | |
| */ | |
| export type SessionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Session. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput> | |
| /** | |
| * Choose, which Session to update. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session updateMany | |
| */ | |
| export type SessionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Sessions. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Sessions to update | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Session updateManyAndReturn | |
| */ | |
| export type SessionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Sessions. | |
| */ | |
| data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Sessions to update | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Session upsert | |
| */ | |
| export type SessionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Session to update in case it exists. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| /** | |
| * In case the Session found by the `where` argument doesn't exist, create a new Session with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput> | |
| /** | |
| * In case the Session was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput> | |
| } | |
| /** | |
| * Session delete | |
| */ | |
| export type SessionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| /** | |
| * Filter which Session to delete. | |
| */ | |
| where: Prisma.SessionWhereUniqueInput | |
| } | |
| /** | |
| * Session deleteMany | |
| */ | |
| export type SessionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Sessions to delete | |
| */ | |
| where?: Prisma.SessionWhereInput | |
| /** | |
| * Limit how many Sessions to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Session without action | |
| */ | |
| export type SessionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/models/User.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `User` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type UserModel = runtime.Types.Result.DefaultSelection<Prisma.$UserPayload> | |
| export type AggregateUser = { | |
| _count: UserCountAggregateOutputType | null | |
| _min: UserMinAggregateOutputType | null | |
| _max: UserMaxAggregateOutputType | null | |
| } | |
| export type UserMinAggregateOutputType = { | |
| id: string | null | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| } | |
| export type UserMaxAggregateOutputType = { | |
| id: string | null | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| } | |
| export type UserCountAggregateOutputType = { | |
| id: number | |
| anonymousId: number | |
| telegramUserId: number | |
| telegramUserData: number | |
| isBlackTheme: number | |
| createdAt: number | |
| updatedAt: number | |
| _all: number | |
| } | |
| export type UserMinAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| } | |
| export type UserMaxAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| } | |
| export type UserCountAggregateInputType = { | |
| id?: true | |
| anonymousId?: true | |
| telegramUserId?: true | |
| telegramUserData?: true | |
| isBlackTheme?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| _all?: true | |
| } | |
| export type UserAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which User to aggregate. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Users | |
| **/ | |
| _count?: true | UserCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: UserMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: UserMaxAggregateInputType | |
| } | |
| export type GetUserAggregateType<T extends UserAggregateArgs> = { | |
| [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateUser[P]> | |
| : Prisma.GetScalarType<T[P], AggregateUser[P]> | |
| } | |
| export type UserGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.UserWhereInput | |
| orderBy?: Prisma.UserOrderByWithAggregationInput | Prisma.UserOrderByWithAggregationInput[] | |
| by: Prisma.UserScalarFieldEnum[] | Prisma.UserScalarFieldEnum | |
| having?: Prisma.UserScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: UserCountAggregateInputType | true | |
| _min?: UserMinAggregateInputType | |
| _max?: UserMaxAggregateInputType | |
| } | |
| export type UserGroupByOutputType = { | |
| id: string | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| telegramUserData: runtime.JsonValue | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| _count: UserCountAggregateOutputType | null | |
| _min: UserMinAggregateOutputType | null | |
| _max: UserMaxAggregateOutputType | null | |
| } | |
| type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<UserGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type UserWhereInput = { | |
| AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| OR?: Prisma.UserWhereInput[] | |
| NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| id?: Prisma.UuidFilter<"User"> | string | |
| anonymousId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| Session?: Prisma.SessionListRelationFilter | |
| Dashboard?: Prisma.DashboardListRelationFilter | |
| } | |
| export type UserOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| Session?: Prisma.SessionOrderByRelationAggregateInput | |
| Dashboard?: Prisma.DashboardOrderByRelationAggregateInput | |
| } | |
| export type UserWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| telegramUserId?: string | |
| AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| OR?: Prisma.UserWhereInput[] | |
| NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[] | |
| anonymousId?: Prisma.StringNullableFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"User"> | Date | string | |
| Session?: Prisma.SessionListRelationFilter | |
| Dashboard?: Prisma.DashboardListRelationFilter | |
| }, "id" | "telegramUserId"> | |
| export type UserOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrderInput | Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| _count?: Prisma.UserCountOrderByAggregateInput | |
| _max?: Prisma.UserMaxOrderByAggregateInput | |
| _min?: Prisma.UserMinOrderByAggregateInput | |
| } | |
| export type UserScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.UserScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"User"> | string | |
| anonymousId?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null | |
| telegramUserId?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null | |
| telegramUserData?: Prisma.JsonNullableWithAggregatesFilter<"User"> | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"User"> | boolean | null | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string | |
| } | |
| export type UserCreateInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionCreateNestedManyWithoutUserInput | |
| Dashboard?: Prisma.DashboardCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput | |
| Dashboard?: Prisma.DashboardUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUpdateManyWithoutUserNestedInput | |
| Dashboard?: Prisma.DashboardUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput | |
| Dashboard?: Prisma.DashboardUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserCreateManyInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| } | |
| export type UserUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| } | |
| export type UserUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| } | |
| export type UserCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| telegramUserData?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| anonymousId?: Prisma.SortOrder | |
| telegramUserId?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| } | |
| export type UserScalarRelationFilter = { | |
| is?: Prisma.UserWhereInput | |
| isNot?: Prisma.UserWhereInput | |
| } | |
| export type StringFieldUpdateOperationsInput = { | |
| set?: string | |
| } | |
| export type NullableStringFieldUpdateOperationsInput = { | |
| set?: string | null | |
| } | |
| export type NullableBoolFieldUpdateOperationsInput = { | |
| set?: boolean | null | |
| } | |
| export type DateTimeFieldUpdateOperationsInput = { | |
| set?: Date | string | |
| } | |
| export type UserCreateNestedOneWithoutSessionInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| } | |
| export type UserUpdateOneRequiredWithoutSessionNestedInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionInput | |
| upsert?: Prisma.UserUpsertWithoutSessionInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutSessionInput, Prisma.UserUpdateWithoutSessionInput>, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| } | |
| export type UserCreateNestedOneWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutDashboardInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| } | |
| export type UserUpdateOneRequiredWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| connectOrCreate?: Prisma.UserCreateOrConnectWithoutDashboardInput | |
| upsert?: Prisma.UserUpsertWithoutDashboardInput | |
| connect?: Prisma.UserWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutDashboardInput, Prisma.UserUpdateWithoutDashboardInput>, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type UserCreateWithoutSessionInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Dashboard?: Prisma.DashboardCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateWithoutSessionInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Dashboard?: Prisma.DashboardUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserCreateOrConnectWithoutSessionInput = { | |
| where: Prisma.UserWhereUniqueInput | |
| create: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| } | |
| export type UserUpsertWithoutSessionInput = { | |
| update: Prisma.XOR<Prisma.UserUpdateWithoutSessionInput, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| create: Prisma.XOR<Prisma.UserCreateWithoutSessionInput, Prisma.UserUncheckedCreateWithoutSessionInput> | |
| where?: Prisma.UserWhereInput | |
| } | |
| export type UserUpdateToOneWithWhereWithoutSessionInput = { | |
| where?: Prisma.UserWhereInput | |
| data: Prisma.XOR<Prisma.UserUpdateWithoutSessionInput, Prisma.UserUncheckedUpdateWithoutSessionInput> | |
| } | |
| export type UserUpdateWithoutSessionInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Dashboard?: Prisma.DashboardUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateWithoutSessionInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Dashboard?: Prisma.DashboardUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserCreateWithoutDashboardInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionCreateNestedManyWithoutUserInput | |
| } | |
| export type UserUncheckedCreateWithoutDashboardInput = { | |
| id?: string | |
| anonymousId?: string | null | |
| telegramUserId?: string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: boolean | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| Session?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput | |
| } | |
| export type UserCreateOrConnectWithoutDashboardInput = { | |
| where: Prisma.UserWhereUniqueInput | |
| create: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type UserUpsertWithoutDashboardInput = { | |
| update: Prisma.XOR<Prisma.UserUpdateWithoutDashboardInput, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| create: Prisma.XOR<Prisma.UserCreateWithoutDashboardInput, Prisma.UserUncheckedCreateWithoutDashboardInput> | |
| where?: Prisma.UserWhereInput | |
| } | |
| export type UserUpdateToOneWithWhereWithoutDashboardInput = { | |
| where?: Prisma.UserWhereInput | |
| data: Prisma.XOR<Prisma.UserUpdateWithoutDashboardInput, Prisma.UserUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type UserUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUpdateManyWithoutUserNestedInput | |
| } | |
| export type UserUncheckedUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| anonymousId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| telegramUserData?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| Session?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput | |
| } | |
| /** | |
| * Count Type UserCountOutputType | |
| */ | |
| export type UserCountOutputType = { | |
| Session: number | |
| Dashboard: number | |
| } | |
| export type UserCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Session?: boolean | UserCountOutputTypeCountSessionArgs | |
| Dashboard?: boolean | UserCountOutputTypeCountDashboardArgs | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the UserCountOutputType | |
| */ | |
| select?: Prisma.UserCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeCountSessionArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.SessionWhereInput | |
| } | |
| /** | |
| * UserCountOutputType without action | |
| */ | |
| export type UserCountOutputTypeCountDashboardArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.DashboardWhereInput | |
| } | |
| export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| Session?: boolean | Prisma.User$SessionArgs<ExtArgs> | |
| Dashboard?: boolean | Prisma.User$DashboardArgs<ExtArgs> | |
| _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| }, ExtArgs["result"]["user"]> | |
| export type UserSelectScalar = { | |
| id?: boolean | |
| anonymousId?: boolean | |
| telegramUserId?: boolean | |
| telegramUserData?: boolean | |
| isBlackTheme?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| } | |
| export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "anonymousId" | "telegramUserId" | "telegramUserData" | "isBlackTheme" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]> | |
| export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Session?: boolean | Prisma.User$SessionArgs<ExtArgs> | |
| Dashboard?: boolean | Prisma.User$DashboardArgs<ExtArgs> | |
| _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type UserIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {} | |
| export type UserIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {} | |
| export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "User" | |
| objects: { | |
| Session: Prisma.$SessionPayload<ExtArgs>[] | |
| Dashboard: Prisma.$DashboardPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| anonymousId: string | null | |
| telegramUserId: string | null | |
| telegramUserData: runtime.JsonValue | null | |
| isBlackTheme: boolean | null | |
| createdAt: Date | |
| updatedAt: Date | |
| }, ExtArgs["result"]["user"]> | |
| composites: {} | |
| } | |
| export type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$UserPayload, S> | |
| export type UserCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: UserCountAggregateInputType | true | |
| } | |
| export interface UserDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } } | |
| /** | |
| * Find zero or one User that matches the filter. | |
| * @param {UserFindUniqueArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends UserFindUniqueArgs>(args: Prisma.SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one User that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first User that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindFirstArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends UserFindFirstArgs>(args?: Prisma.SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first User that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User | |
| * @example | |
| * // Get one User | |
| * const user = await prisma.user.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Users that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Users | |
| * const users = await prisma.user.findMany() | |
| * | |
| * // Get first 10 Users | |
| * const users = await prisma.user.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends UserFindManyArgs>(args?: Prisma.SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a User. | |
| * @param {UserCreateArgs} args - Arguments to create a User. | |
| * @example | |
| * // Create one User | |
| * const User = await prisma.user.create({ | |
| * data: { | |
| * // ... data to create a User | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends UserCreateArgs>(args: Prisma.SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Users. | |
| * @param {UserCreateManyArgs} args - Arguments to create many Users. | |
| * @example | |
| * // Create many Users | |
| * const user = await prisma.user.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends UserCreateManyArgs>(args?: Prisma.SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Users and returns the data saved in the database. | |
| * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users. | |
| * @example | |
| * // Create many Users | |
| * const user = await prisma.user.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Users and only return the `id` | |
| * const userWithIdOnly = await prisma.user.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a User. | |
| * @param {UserDeleteArgs} args - Arguments to delete one User. | |
| * @example | |
| * // Delete one User | |
| * const User = await prisma.user.delete({ | |
| * where: { | |
| * // ... filter to delete one User | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends UserDeleteArgs>(args: Prisma.SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one User. | |
| * @param {UserUpdateArgs} args - Arguments to update one User. | |
| * @example | |
| * // Update one User | |
| * const user = await prisma.user.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends UserUpdateArgs>(args: Prisma.SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Users. | |
| * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete. | |
| * @example | |
| * // Delete a few Users | |
| * const { count } = await prisma.user.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends UserDeleteManyArgs>(args?: Prisma.SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Users. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Users | |
| * const user = await prisma.user.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends UserUpdateManyArgs>(args: Prisma.SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Users and returns the data updated in the database. | |
| * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users. | |
| * @example | |
| * // Update many Users | |
| * const user = await prisma.user.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Users and only return the `id` | |
| * const userWithIdOnly = await prisma.user.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one User. | |
| * @param {UserUpsertArgs} args - Arguments to update or create a User. | |
| * @example | |
| * // Update or create a User | |
| * const user = await prisma.user.upsert({ | |
| * create: { | |
| * // ... data to create a User | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the User we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends UserUpsertArgs>(args: Prisma.SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Users. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserCountArgs} args - Arguments to filter Users to count. | |
| * @example | |
| * // Count the number of Users | |
| * const count = await prisma.user.count({ | |
| * where: { | |
| * // ... the filter for the Users we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends UserCountArgs>( | |
| args?: Prisma.Subset<T, UserCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], UserCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a User. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends UserAggregateArgs>(args: Prisma.Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>> | |
| /** | |
| * Group by User. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {UserGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends UserGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: UserGroupByArgs['orderBy'] } | |
| : { orderBy?: UserGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the User model | |
| */ | |
| readonly fields: UserFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for User. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__UserClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Session<T extends Prisma.User$SessionArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$SessionArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| Dashboard<T extends Prisma.User$DashboardArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$DashboardArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the User model | |
| */ | |
| export interface UserFieldRefs { | |
| readonly id: Prisma.FieldRef<"User", 'String'> | |
| readonly anonymousId: Prisma.FieldRef<"User", 'String'> | |
| readonly telegramUserId: Prisma.FieldRef<"User", 'String'> | |
| readonly telegramUserData: Prisma.FieldRef<"User", 'Json'> | |
| readonly isBlackTheme: Prisma.FieldRef<"User", 'Boolean'> | |
| readonly createdAt: Prisma.FieldRef<"User", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"User", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * User findUnique | |
| */ | |
| export type UserFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User findUniqueOrThrow | |
| */ | |
| export type UserFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User findFirst | |
| */ | |
| export type UserFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Users. | |
| */ | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User findFirstOrThrow | |
| */ | |
| export type UserFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which User to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Users. | |
| */ | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User findMany | |
| */ | |
| export type UserFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Users to fetch. | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Users to fetch. | |
| */ | |
| orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Users. | |
| */ | |
| cursor?: Prisma.UserWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Users from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Users. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[] | |
| } | |
| /** | |
| * User create | |
| */ | |
| export type UserCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a User. | |
| */ | |
| data?: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput> | |
| } | |
| /** | |
| * User createMany | |
| */ | |
| export type UserCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Users. | |
| */ | |
| data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * User createManyAndReturn | |
| */ | |
| export type UserCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Users. | |
| */ | |
| data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * User update | |
| */ | |
| export type UserUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a User. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput> | |
| /** | |
| * Choose, which User to update. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User updateMany | |
| */ | |
| export type UserUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Users. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Users to update | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User updateManyAndReturn | |
| */ | |
| export type UserUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Users. | |
| */ | |
| data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Users to update | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User upsert | |
| */ | |
| export type UserUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the User to update in case it exists. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| /** | |
| * In case the User found by the `where` argument doesn't exist, create a new User with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput> | |
| /** | |
| * In case the User was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput> | |
| } | |
| /** | |
| * User delete | |
| */ | |
| export type UserDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| /** | |
| * Filter which User to delete. | |
| */ | |
| where: Prisma.UserWhereUniqueInput | |
| } | |
| /** | |
| * User deleteMany | |
| */ | |
| export type UserDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Users to delete | |
| */ | |
| where?: Prisma.UserWhereInput | |
| /** | |
| * Limit how many Users to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * User.Session | |
| */ | |
| export type User$SessionArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Session | |
| */ | |
| select?: Prisma.SessionSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Session | |
| */ | |
| omit?: Prisma.SessionOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.SessionInclude<ExtArgs> | null | |
| where?: Prisma.SessionWhereInput | |
| orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[] | |
| cursor?: Prisma.SessionWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[] | |
| } | |
| /** | |
| * User.Dashboard | |
| */ | |
| export type User$DashboardArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Dashboard | |
| */ | |
| select?: Prisma.DashboardSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Dashboard | |
| */ | |
| omit?: Prisma.DashboardOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.DashboardInclude<ExtArgs> | null | |
| where?: Prisma.DashboardWhereInput | |
| orderBy?: Prisma.DashboardOrderByWithRelationInput | Prisma.DashboardOrderByWithRelationInput[] | |
| cursor?: Prisma.DashboardWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.DashboardScalarFieldEnum | Prisma.DashboardScalarFieldEnum[] | |
| } | |
| /** | |
| * User without action | |
| */ | |
| export type UserDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the User | |
| */ | |
| select?: Prisma.UserSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the User | |
| */ | |
| omit?: Prisma.UserOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.UserInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/models/Widget.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `Widget` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type WidgetModel = runtime.Types.Result.DefaultSelection<Prisma.$WidgetPayload> | |
| export type AggregateWidget = { | |
| _count: WidgetCountAggregateOutputType | null | |
| _avg: WidgetAvgAggregateOutputType | null | |
| _sum: WidgetSumAggregateOutputType | null | |
| _min: WidgetMinAggregateOutputType | null | |
| _max: WidgetMaxAggregateOutputType | null | |
| } | |
| export type WidgetAvgAggregateOutputType = { | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| } | |
| export type WidgetSumAggregateOutputType = { | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| } | |
| export type WidgetMinAggregateOutputType = { | |
| id: string | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetMaxAggregateOutputType = { | |
| id: string | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetCountAggregateOutputType = { | |
| id: number | |
| options: number | |
| state: number | |
| columnIndex: number | |
| rowIndex: number | |
| columnCount: number | |
| rowCount: number | |
| isBlackTheme: number | |
| backgroundColor: number | |
| primaryColor: number | |
| positiveColor: number | |
| negativeColor: number | |
| dashboardId: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type WidgetAvgAggregateInputType = { | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| } | |
| export type WidgetSumAggregateInputType = { | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| } | |
| export type WidgetMinAggregateInputType = { | |
| id?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetMaxAggregateInputType = { | |
| id?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetCountAggregateInputType = { | |
| id?: true | |
| options?: true | |
| state?: true | |
| columnIndex?: true | |
| rowIndex?: true | |
| columnCount?: true | |
| rowCount?: true | |
| isBlackTheme?: true | |
| backgroundColor?: true | |
| primaryColor?: true | |
| positiveColor?: true | |
| negativeColor?: true | |
| dashboardId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type WidgetAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Widget to aggregate. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned Widgets | |
| **/ | |
| _count?: true | WidgetCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to average | |
| **/ | |
| _avg?: WidgetAvgAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to sum | |
| **/ | |
| _sum?: WidgetSumAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: WidgetMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: WidgetMaxAggregateInputType | |
| } | |
| export type GetWidgetAggregateType<T extends WidgetAggregateArgs> = { | |
| [P in keyof T & keyof AggregateWidget]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateWidget[P]> | |
| : Prisma.GetScalarType<T[P], AggregateWidget[P]> | |
| } | |
| export type WidgetGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetWhereInput | |
| orderBy?: Prisma.WidgetOrderByWithAggregationInput | Prisma.WidgetOrderByWithAggregationInput[] | |
| by: Prisma.WidgetScalarFieldEnum[] | Prisma.WidgetScalarFieldEnum | |
| having?: Prisma.WidgetScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: WidgetCountAggregateInputType | true | |
| _avg?: WidgetAvgAggregateInputType | |
| _sum?: WidgetSumAggregateInputType | |
| _min?: WidgetMinAggregateInputType | |
| _max?: WidgetMaxAggregateInputType | |
| } | |
| export type WidgetGroupByOutputType = { | |
| id: string | |
| options: runtime.JsonValue | null | |
| state: runtime.JsonValue | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: WidgetCountAggregateOutputType | null | |
| _avg: WidgetAvgAggregateOutputType | null | |
| _sum: WidgetSumAggregateOutputType | null | |
| _min: WidgetMinAggregateOutputType | null | |
| _max: WidgetMaxAggregateOutputType | null | |
| } | |
| type GetWidgetGroupByPayload<T extends WidgetGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<WidgetGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof WidgetGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], WidgetGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], WidgetGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type WidgetWhereInput = { | |
| AND?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| OR?: Prisma.WidgetWhereInput[] | |
| NOT?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| id?: Prisma.UuidFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| Dashboard?: Prisma.XOR<Prisma.DashboardScalarRelationFilter, Prisma.DashboardWhereInput> | |
| WidgetLog?: Prisma.WidgetLogListRelationFilter | |
| } | |
| export type WidgetOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrderInput | Prisma.SortOrder | |
| state?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| Dashboard?: Prisma.DashboardOrderByWithRelationInput | |
| WidgetLog?: Prisma.WidgetLogOrderByRelationAggregateInput | |
| } | |
| export type WidgetWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| OR?: Prisma.WidgetWhereInput[] | |
| NOT?: Prisma.WidgetWhereInput | Prisma.WidgetWhereInput[] | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| Dashboard?: Prisma.XOR<Prisma.DashboardScalarRelationFilter, Prisma.DashboardWhereInput> | |
| WidgetLog?: Prisma.WidgetLogListRelationFilter | |
| }, "id"> | |
| export type WidgetOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrderInput | Prisma.SortOrder | |
| state?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrderInput | Prisma.SortOrder | |
| columnCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| rowCount?: Prisma.SortOrderInput | Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrderInput | Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrderInput | Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.WidgetCountOrderByAggregateInput | |
| _avg?: Prisma.WidgetAvgOrderByAggregateInput | |
| _max?: Prisma.WidgetMaxOrderByAggregateInput | |
| _min?: Prisma.WidgetMinOrderByAggregateInput | |
| _sum?: Prisma.WidgetSumOrderByAggregateInput | |
| } | |
| export type WidgetScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.WidgetScalarWhereWithAggregatesInput | Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.WidgetScalarWhereWithAggregatesInput | Prisma.WidgetScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableWithAggregatesFilter<"Widget"> | |
| state?: Prisma.JsonNullableWithAggregatesFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableWithAggregatesFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableWithAggregatesFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableWithAggregatesFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidWithAggregatesFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"Widget"> | Date | string | null | |
| } | |
| export type WidgetCreateInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Dashboard: Prisma.DashboardCreateNestedOneWithoutWidgetInput | |
| WidgetLog?: Prisma.WidgetLogCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Dashboard?: Prisma.DashboardUpdateOneRequiredWithoutWidgetNestedInput | |
| WidgetLog?: Prisma.WidgetLogUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetCreateManyInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetListRelationFilter = { | |
| every?: Prisma.WidgetWhereInput | |
| some?: Prisma.WidgetWhereInput | |
| none?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type WidgetCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| options?: Prisma.SortOrder | |
| state?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetAvgOrderByAggregateInput = { | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| } | |
| export type WidgetMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| isBlackTheme?: Prisma.SortOrder | |
| backgroundColor?: Prisma.SortOrder | |
| primaryColor?: Prisma.SortOrder | |
| positiveColor?: Prisma.SortOrder | |
| negativeColor?: Prisma.SortOrder | |
| dashboardId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetSumOrderByAggregateInput = { | |
| columnIndex?: Prisma.SortOrder | |
| rowIndex?: Prisma.SortOrder | |
| columnCount?: Prisma.SortOrder | |
| rowCount?: Prisma.SortOrder | |
| } | |
| export type WidgetScalarRelationFilter = { | |
| is?: Prisma.WidgetWhereInput | |
| isNot?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetCreateNestedManyWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| } | |
| export type WidgetUncheckedCreateNestedManyWithoutDashboardInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| } | |
| export type WidgetUpdateManyWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| upsert?: Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| set?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| delete?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| update?: Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput[] | |
| updateMany?: Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput | Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput[] | |
| deleteMany?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| } | |
| export type WidgetUncheckedUpdateManyWithoutDashboardNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | Prisma.WidgetCreateWithoutDashboardInput[] | Prisma.WidgetUncheckedCreateWithoutDashboardInput[] | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutDashboardInput | Prisma.WidgetCreateOrConnectWithoutDashboardInput[] | |
| upsert?: Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpsertWithWhereUniqueWithoutDashboardInput[] | |
| createMany?: Prisma.WidgetCreateManyDashboardInputEnvelope | |
| set?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| delete?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| connect?: Prisma.WidgetWhereUniqueInput | Prisma.WidgetWhereUniqueInput[] | |
| update?: Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput | Prisma.WidgetUpdateWithWhereUniqueWithoutDashboardInput[] | |
| updateMany?: Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput | Prisma.WidgetUpdateManyWithWhereWithoutDashboardInput[] | |
| deleteMany?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| } | |
| export type NullableIntFieldUpdateOperationsInput = { | |
| set?: number | null | |
| increment?: number | |
| decrement?: number | |
| multiply?: number | |
| divide?: number | |
| } | |
| export type WidgetCreateNestedOneWithoutWidgetLogInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutWidgetLogInput | |
| connect?: Prisma.WidgetWhereUniqueInput | |
| } | |
| export type WidgetUpdateOneRequiredWithoutWidgetLogNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| connectOrCreate?: Prisma.WidgetCreateOrConnectWithoutWidgetLogInput | |
| upsert?: Prisma.WidgetUpsertWithoutWidgetLogInput | |
| connect?: Prisma.WidgetWhereUniqueInput | |
| update?: Prisma.XOR<Prisma.XOR<Prisma.WidgetUpdateToOneWithWhereWithoutWidgetLogInput, Prisma.WidgetUpdateWithoutWidgetLogInput>, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| } | |
| export type WidgetCreateWithoutDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateWithoutDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedCreateNestedManyWithoutWidgetInput | |
| } | |
| export type WidgetCreateOrConnectWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type WidgetCreateManyDashboardInputEnvelope = { | |
| data: Prisma.WidgetCreateManyDashboardInput | Prisma.WidgetCreateManyDashboardInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type WidgetUpsertWithWhereUniqueWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| update: Prisma.XOR<Prisma.WidgetUpdateWithoutDashboardInput, Prisma.WidgetUncheckedUpdateWithoutDashboardInput> | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutDashboardInput, Prisma.WidgetUncheckedCreateWithoutDashboardInput> | |
| } | |
| export type WidgetUpdateWithWhereUniqueWithoutDashboardInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateWithoutDashboardInput, Prisma.WidgetUncheckedUpdateWithoutDashboardInput> | |
| } | |
| export type WidgetUpdateManyWithWhereWithoutDashboardInput = { | |
| where: Prisma.WidgetScalarWhereInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyWithoutDashboardInput> | |
| } | |
| export type WidgetScalarWhereInput = { | |
| AND?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| OR?: Prisma.WidgetScalarWhereInput[] | |
| NOT?: Prisma.WidgetScalarWhereInput | Prisma.WidgetScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"Widget"> | string | |
| options?: Prisma.JsonNullableFilter<"Widget"> | |
| state?: Prisma.JsonNullableFilter<"Widget"> | |
| columnIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowIndex?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| columnCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| rowCount?: Prisma.IntNullableFilter<"Widget"> | number | null | |
| isBlackTheme?: Prisma.BoolNullableFilter<"Widget"> | boolean | null | |
| backgroundColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| primaryColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| positiveColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| negativeColor?: Prisma.StringNullableFilter<"Widget"> | string | null | |
| dashboardId?: Prisma.UuidFilter<"Widget"> | string | |
| createdAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"Widget"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"Widget"> | Date | string | null | |
| } | |
| export type WidgetCreateWithoutWidgetLogInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Dashboard: Prisma.DashboardCreateNestedOneWithoutWidgetInput | |
| } | |
| export type WidgetUncheckedCreateWithoutWidgetLogInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| dashboardId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetCreateOrConnectWithoutWidgetLogInput = { | |
| where: Prisma.WidgetWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| } | |
| export type WidgetUpsertWithoutWidgetLogInput = { | |
| update: Prisma.XOR<Prisma.WidgetUpdateWithoutWidgetLogInput, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| create: Prisma.XOR<Prisma.WidgetCreateWithoutWidgetLogInput, Prisma.WidgetUncheckedCreateWithoutWidgetLogInput> | |
| where?: Prisma.WidgetWhereInput | |
| } | |
| export type WidgetUpdateToOneWithWhereWithoutWidgetLogInput = { | |
| where?: Prisma.WidgetWhereInput | |
| data: Prisma.XOR<Prisma.WidgetUpdateWithoutWidgetLogInput, Prisma.WidgetUncheckedUpdateWithoutWidgetLogInput> | |
| } | |
| export type WidgetUpdateWithoutWidgetLogInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Dashboard?: Prisma.DashboardUpdateOneRequiredWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateWithoutWidgetLogInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| dashboardId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetCreateManyDashboardInput = { | |
| id?: string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: number | null | |
| rowIndex?: number | null | |
| columnCount?: number | null | |
| rowCount?: number | null | |
| isBlackTheme?: boolean | null | |
| backgroundColor?: string | null | |
| primaryColor?: string | null | |
| positiveColor?: string | null | |
| negativeColor?: string | null | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| WidgetLog?: Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput | |
| } | |
| export type WidgetUncheckedUpdateManyWithoutDashboardInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| options?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| state?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| columnIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowIndex?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| columnCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| rowCount?: Prisma.NullableIntFieldUpdateOperationsInput | number | null | |
| isBlackTheme?: Prisma.NullableBoolFieldUpdateOperationsInput | boolean | null | |
| backgroundColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| primaryColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| positiveColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| negativeColor?: Prisma.NullableStringFieldUpdateOperationsInput | string | null | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| /** | |
| * Count Type WidgetCountOutputType | |
| */ | |
| export type WidgetCountOutputType = { | |
| WidgetLog: number | |
| } | |
| export type WidgetCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| WidgetLog?: boolean | WidgetCountOutputTypeCountWidgetLogArgs | |
| } | |
| /** | |
| * WidgetCountOutputType without action | |
| */ | |
| export type WidgetCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetCountOutputType | |
| */ | |
| select?: Prisma.WidgetCountOutputTypeSelect<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetCountOutputType without action | |
| */ | |
| export type WidgetCountOutputTypeCountWidgetLogArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetLogWhereInput | |
| } | |
| export type WidgetSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| WidgetLog?: boolean | Prisma.Widget$WidgetLogArgs<ExtArgs> | |
| _count?: boolean | Prisma.WidgetCountOutputTypeDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widget"]> | |
| export type WidgetSelectScalar = { | |
| id?: boolean | |
| options?: boolean | |
| state?: boolean | |
| columnIndex?: boolean | |
| rowIndex?: boolean | |
| columnCount?: boolean | |
| rowCount?: boolean | |
| isBlackTheme?: boolean | |
| backgroundColor?: boolean | |
| primaryColor?: boolean | |
| positiveColor?: boolean | |
| negativeColor?: boolean | |
| dashboardId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type WidgetOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "options" | "state" | "columnIndex" | "rowIndex" | "columnCount" | "rowCount" | "isBlackTheme" | "backgroundColor" | "primaryColor" | "positiveColor" | "negativeColor" | "dashboardId" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["widget"]> | |
| export type WidgetInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| WidgetLog?: boolean | Prisma.Widget$WidgetLogArgs<ExtArgs> | |
| _count?: boolean | Prisma.WidgetCountOutputTypeDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Dashboard?: boolean | Prisma.DashboardDefaultArgs<ExtArgs> | |
| } | |
| export type $WidgetPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "Widget" | |
| objects: { | |
| Dashboard: Prisma.$DashboardPayload<ExtArgs> | |
| WidgetLog: Prisma.$WidgetLogPayload<ExtArgs>[] | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| options: runtime.JsonValue | null | |
| state: runtime.JsonValue | null | |
| columnIndex: number | null | |
| rowIndex: number | null | |
| columnCount: number | null | |
| rowCount: number | null | |
| isBlackTheme: boolean | null | |
| backgroundColor: string | null | |
| primaryColor: string | null | |
| positiveColor: string | null | |
| negativeColor: string | null | |
| dashboardId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["widget"]> | |
| composites: {} | |
| } | |
| export type WidgetGetPayload<S extends boolean | null | undefined | WidgetDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$WidgetPayload, S> | |
| export type WidgetCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<WidgetFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: WidgetCountAggregateInputType | true | |
| } | |
| export interface WidgetDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Widget'], meta: { name: 'Widget' } } | |
| /** | |
| * Find zero or one Widget that matches the filter. | |
| * @param {WidgetFindUniqueArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends WidgetFindUniqueArgs>(args: Prisma.SelectSubset<T, WidgetFindUniqueArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one Widget that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {WidgetFindUniqueOrThrowArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends WidgetFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, WidgetFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Widget that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindFirstArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends WidgetFindFirstArgs>(args?: Prisma.SelectSubset<T, WidgetFindFirstArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first Widget that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindFirstOrThrowArgs} args - Arguments to find a Widget | |
| * @example | |
| * // Get one Widget | |
| * const widget = await prisma.widget.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends WidgetFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, WidgetFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more Widgets that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all Widgets | |
| * const widgets = await prisma.widget.findMany() | |
| * | |
| * // Get first 10 Widgets | |
| * const widgets = await prisma.widget.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const widgetWithIdOnly = await prisma.widget.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends WidgetFindManyArgs>(args?: Prisma.SelectSubset<T, WidgetFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a Widget. | |
| * @param {WidgetCreateArgs} args - Arguments to create a Widget. | |
| * @example | |
| * // Create one Widget | |
| * const Widget = await prisma.widget.create({ | |
| * data: { | |
| * // ... data to create a Widget | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends WidgetCreateArgs>(args: Prisma.SelectSubset<T, WidgetCreateArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many Widgets. | |
| * @param {WidgetCreateManyArgs} args - Arguments to create many Widgets. | |
| * @example | |
| * // Create many Widgets | |
| * const widget = await prisma.widget.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends WidgetCreateManyArgs>(args?: Prisma.SelectSubset<T, WidgetCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many Widgets and returns the data saved in the database. | |
| * @param {WidgetCreateManyAndReturnArgs} args - Arguments to create many Widgets. | |
| * @example | |
| * // Create many Widgets | |
| * const widget = await prisma.widget.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many Widgets and only return the `id` | |
| * const widgetWithIdOnly = await prisma.widget.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends WidgetCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, WidgetCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a Widget. | |
| * @param {WidgetDeleteArgs} args - Arguments to delete one Widget. | |
| * @example | |
| * // Delete one Widget | |
| * const Widget = await prisma.widget.delete({ | |
| * where: { | |
| * // ... filter to delete one Widget | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends WidgetDeleteArgs>(args: Prisma.SelectSubset<T, WidgetDeleteArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one Widget. | |
| * @param {WidgetUpdateArgs} args - Arguments to update one Widget. | |
| * @example | |
| * // Update one Widget | |
| * const widget = await prisma.widget.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends WidgetUpdateArgs>(args: Prisma.SelectSubset<T, WidgetUpdateArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more Widgets. | |
| * @param {WidgetDeleteManyArgs} args - Arguments to filter Widgets to delete. | |
| * @example | |
| * // Delete a few Widgets | |
| * const { count } = await prisma.widget.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends WidgetDeleteManyArgs>(args?: Prisma.SelectSubset<T, WidgetDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Widgets. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many Widgets | |
| * const widget = await prisma.widget.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends WidgetUpdateManyArgs>(args: Prisma.SelectSubset<T, WidgetUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more Widgets and returns the data updated in the database. | |
| * @param {WidgetUpdateManyAndReturnArgs} args - Arguments to update many Widgets. | |
| * @example | |
| * // Update many Widgets | |
| * const widget = await prisma.widget.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more Widgets and only return the `id` | |
| * const widgetWithIdOnly = await prisma.widget.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends WidgetUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, WidgetUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one Widget. | |
| * @param {WidgetUpsertArgs} args - Arguments to update or create a Widget. | |
| * @example | |
| * // Update or create a Widget | |
| * const widget = await prisma.widget.upsert({ | |
| * create: { | |
| * // ... data to create a Widget | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the Widget we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends WidgetUpsertArgs>(args: Prisma.SelectSubset<T, WidgetUpsertArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of Widgets. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetCountArgs} args - Arguments to filter Widgets to count. | |
| * @example | |
| * // Count the number of Widgets | |
| * const count = await prisma.widget.count({ | |
| * where: { | |
| * // ... the filter for the Widgets we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends WidgetCountArgs>( | |
| args?: Prisma.Subset<T, WidgetCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], WidgetCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a Widget. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends WidgetAggregateArgs>(args: Prisma.Subset<T, WidgetAggregateArgs>): Prisma.PrismaPromise<GetWidgetAggregateType<T>> | |
| /** | |
| * Group by Widget. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends WidgetGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: WidgetGroupByArgs['orderBy'] } | |
| : { orderBy?: WidgetGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, WidgetGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWidgetGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the Widget model | |
| */ | |
| readonly fields: WidgetFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for Widget. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__WidgetClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Dashboard<T extends Prisma.DashboardDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.DashboardDefaultArgs<ExtArgs>>): Prisma.Prisma__DashboardClient<runtime.Types.Result.GetResult<Prisma.$DashboardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| WidgetLog<T extends Prisma.Widget$WidgetLogArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Widget$WidgetLogArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the Widget model | |
| */ | |
| export interface WidgetFieldRefs { | |
| readonly id: Prisma.FieldRef<"Widget", 'String'> | |
| readonly options: Prisma.FieldRef<"Widget", 'Json'> | |
| readonly state: Prisma.FieldRef<"Widget", 'Json'> | |
| readonly columnIndex: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly rowIndex: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly columnCount: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly rowCount: Prisma.FieldRef<"Widget", 'Int'> | |
| readonly isBlackTheme: Prisma.FieldRef<"Widget", 'Boolean'> | |
| readonly backgroundColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly primaryColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly positiveColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly negativeColor: Prisma.FieldRef<"Widget", 'String'> | |
| readonly dashboardId: Prisma.FieldRef<"Widget", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"Widget", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * Widget findUnique | |
| */ | |
| export type WidgetFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget findUniqueOrThrow | |
| */ | |
| export type WidgetFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget findFirst | |
| */ | |
| export type WidgetFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Widgets. | |
| */ | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget findFirstOrThrow | |
| */ | |
| export type WidgetFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widget to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of Widgets. | |
| */ | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget findMany | |
| */ | |
| export type WidgetFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter, which Widgets to fetch. | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of Widgets to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetOrderByWithRelationInput | Prisma.WidgetOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing Widgets. | |
| */ | |
| cursor?: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` Widgets from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` Widgets. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.WidgetScalarFieldEnum | Prisma.WidgetScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget create | |
| */ | |
| export type WidgetCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a Widget. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetCreateInput, Prisma.WidgetUncheckedCreateInput> | |
| } | |
| /** | |
| * Widget createMany | |
| */ | |
| export type WidgetCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many Widgets. | |
| */ | |
| data: Prisma.WidgetCreateManyInput | Prisma.WidgetCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * Widget createManyAndReturn | |
| */ | |
| export type WidgetCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many Widgets. | |
| */ | |
| data: Prisma.WidgetCreateManyInput | Prisma.WidgetCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Widget update | |
| */ | |
| export type WidgetUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a Widget. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateInput, Prisma.WidgetUncheckedUpdateInput> | |
| /** | |
| * Choose, which Widget to update. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget updateMany | |
| */ | |
| export type WidgetUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update Widgets. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Widgets to update | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Widget updateManyAndReturn | |
| */ | |
| export type WidgetUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * The data used to update Widgets. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetUpdateManyMutationInput, Prisma.WidgetUncheckedUpdateManyInput> | |
| /** | |
| * Filter which Widgets to update | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * Widget upsert | |
| */ | |
| export type WidgetUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the Widget to update in case it exists. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| /** | |
| * In case the Widget found by the `where` argument doesn't exist, create a new Widget with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.WidgetCreateInput, Prisma.WidgetUncheckedCreateInput> | |
| /** | |
| * In case the Widget was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.WidgetUpdateInput, Prisma.WidgetUncheckedUpdateInput> | |
| } | |
| /** | |
| * Widget delete | |
| */ | |
| export type WidgetDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| /** | |
| * Filter which Widget to delete. | |
| */ | |
| where: Prisma.WidgetWhereUniqueInput | |
| } | |
| /** | |
| * Widget deleteMany | |
| */ | |
| export type WidgetDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which Widgets to delete | |
| */ | |
| where?: Prisma.WidgetWhereInput | |
| /** | |
| * Limit how many Widgets to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * Widget.WidgetLog | |
| */ | |
| export type Widget$WidgetLogArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| where?: Prisma.WidgetLogWhereInput | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| take?: number | |
| skip?: number | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * Widget without action | |
| */ | |
| export type WidgetDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the Widget | |
| */ | |
| select?: Prisma.WidgetSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the Widget | |
| */ | |
| omit?: Prisma.WidgetOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/models/WidgetLog.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports the `WidgetLog` model and its related types. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import type * as $Enums from "../enums" | |
| import type * as Prisma from "../internal/prismaNamespace" | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLogModel = runtime.Types.Result.DefaultSelection<Prisma.$WidgetLogPayload> | |
| export type AggregateWidgetLog = { | |
| _count: WidgetLogCountAggregateOutputType | null | |
| _min: WidgetLogMinAggregateOutputType | null | |
| _max: WidgetLogMaxAggregateOutputType | null | |
| } | |
| export type WidgetLogMinAggregateOutputType = { | |
| id: string | null | |
| widgetId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetLogMaxAggregateOutputType = { | |
| id: string | null | |
| widgetId: string | null | |
| createdAt: Date | null | |
| updatedAt: Date | null | |
| deletedAt: Date | null | |
| } | |
| export type WidgetLogCountAggregateOutputType = { | |
| id: number | |
| oldOptions: number | |
| newOptions: number | |
| oldState: number | |
| newState: number | |
| widgetId: number | |
| createdAt: number | |
| updatedAt: number | |
| deletedAt: number | |
| _all: number | |
| } | |
| export type WidgetLogMinAggregateInputType = { | |
| id?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetLogMaxAggregateInputType = { | |
| id?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| } | |
| export type WidgetLogCountAggregateInputType = { | |
| id?: true | |
| oldOptions?: true | |
| newOptions?: true | |
| oldState?: true | |
| newState?: true | |
| widgetId?: true | |
| createdAt?: true | |
| updatedAt?: true | |
| deletedAt?: true | |
| _all?: true | |
| } | |
| export type WidgetLogAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which WidgetLog to aggregate. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the start position | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Count returned WidgetLogs | |
| **/ | |
| _count?: true | WidgetLogCountAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the minimum value | |
| **/ | |
| _min?: WidgetLogMinAggregateInputType | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} | |
| * | |
| * Select which fields to find the maximum value | |
| **/ | |
| _max?: WidgetLogMaxAggregateInputType | |
| } | |
| export type GetWidgetLogAggregateType<T extends WidgetLogAggregateArgs> = { | |
| [P in keyof T & keyof AggregateWidgetLog]: P extends '_count' | 'count' | |
| ? T[P] extends true | |
| ? number | |
| : Prisma.GetScalarType<T[P], AggregateWidgetLog[P]> | |
| : Prisma.GetScalarType<T[P], AggregateWidgetLog[P]> | |
| } | |
| export type WidgetLogGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| where?: Prisma.WidgetLogWhereInput | |
| orderBy?: Prisma.WidgetLogOrderByWithAggregationInput | Prisma.WidgetLogOrderByWithAggregationInput[] | |
| by: Prisma.WidgetLogScalarFieldEnum[] | Prisma.WidgetLogScalarFieldEnum | |
| having?: Prisma.WidgetLogScalarWhereWithAggregatesInput | |
| take?: number | |
| skip?: number | |
| _count?: WidgetLogCountAggregateInputType | true | |
| _min?: WidgetLogMinAggregateInputType | |
| _max?: WidgetLogMaxAggregateInputType | |
| } | |
| export type WidgetLogGroupByOutputType = { | |
| id: string | |
| oldOptions: runtime.JsonValue | null | |
| newOptions: runtime.JsonValue | null | |
| oldState: runtime.JsonValue | null | |
| newState: runtime.JsonValue | null | |
| widgetId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| _count: WidgetLogCountAggregateOutputType | null | |
| _min: WidgetLogMinAggregateOutputType | null | |
| _max: WidgetLogMaxAggregateOutputType | null | |
| } | |
| type GetWidgetLogGroupByPayload<T extends WidgetLogGroupByArgs> = Prisma.PrismaPromise< | |
| Array< | |
| Prisma.PickEnumerable<WidgetLogGroupByOutputType, T['by']> & | |
| { | |
| [P in ((keyof T) & (keyof WidgetLogGroupByOutputType))]: P extends '_count' | |
| ? T[P] extends boolean | |
| ? number | |
| : Prisma.GetScalarType<T[P], WidgetLogGroupByOutputType[P]> | |
| : Prisma.GetScalarType<T[P], WidgetLogGroupByOutputType[P]> | |
| } | |
| > | |
| > | |
| export type WidgetLogWhereInput = { | |
| AND?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| OR?: Prisma.WidgetLogWhereInput[] | |
| NOT?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| id?: Prisma.UuidFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| Widget?: Prisma.XOR<Prisma.WidgetScalarRelationFilter, Prisma.WidgetWhereInput> | |
| } | |
| export type WidgetLogOrderByWithRelationInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| oldState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| Widget?: Prisma.WidgetOrderByWithRelationInput | |
| } | |
| export type WidgetLogWhereUniqueInput = Prisma.AtLeast<{ | |
| id?: string | |
| AND?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| OR?: Prisma.WidgetLogWhereInput[] | |
| NOT?: Prisma.WidgetLogWhereInput | Prisma.WidgetLogWhereInput[] | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| Widget?: Prisma.XOR<Prisma.WidgetScalarRelationFilter, Prisma.WidgetWhereInput> | |
| }, "id"> | |
| export type WidgetLogOrderByWithAggregationInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newOptions?: Prisma.SortOrderInput | Prisma.SortOrder | |
| oldState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| newState?: Prisma.SortOrderInput | Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrderInput | Prisma.SortOrder | |
| _count?: Prisma.WidgetLogCountOrderByAggregateInput | |
| _max?: Prisma.WidgetLogMaxOrderByAggregateInput | |
| _min?: Prisma.WidgetLogMinOrderByAggregateInput | |
| } | |
| export type WidgetLogScalarWhereWithAggregatesInput = { | |
| AND?: Prisma.WidgetLogScalarWhereWithAggregatesInput | Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| OR?: Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| NOT?: Prisma.WidgetLogScalarWhereWithAggregatesInput | Prisma.WidgetLogScalarWhereWithAggregatesInput[] | |
| id?: Prisma.UuidWithAggregatesFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableWithAggregatesFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidWithAggregatesFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeWithAggregatesFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeWithAggregatesFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableWithAggregatesFilter<"WidgetLog"> | Date | string | null | |
| } | |
| export type WidgetLogCreateInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| Widget: Prisma.WidgetCreateNestedOneWithoutWidgetLogInput | |
| } | |
| export type WidgetLogUncheckedCreateInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| Widget?: Prisma.WidgetUpdateOneRequiredWithoutWidgetLogNestedInput | |
| } | |
| export type WidgetLogUncheckedUpdateInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogCreateManyInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId: string | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateManyMutationInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateManyInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| widgetId?: Prisma.StringFieldUpdateOperationsInput | string | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogListRelationFilter = { | |
| every?: Prisma.WidgetLogWhereInput | |
| some?: Prisma.WidgetLogWhereInput | |
| none?: Prisma.WidgetLogWhereInput | |
| } | |
| export type WidgetLogOrderByRelationAggregateInput = { | |
| _count?: Prisma.SortOrder | |
| } | |
| export type WidgetLogCountOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| oldOptions?: Prisma.SortOrder | |
| newOptions?: Prisma.SortOrder | |
| oldState?: Prisma.SortOrder | |
| newState?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogMaxOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogMinOrderByAggregateInput = { | |
| id?: Prisma.SortOrder | |
| widgetId?: Prisma.SortOrder | |
| createdAt?: Prisma.SortOrder | |
| updatedAt?: Prisma.SortOrder | |
| deletedAt?: Prisma.SortOrder | |
| } | |
| export type WidgetLogCreateNestedManyWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| } | |
| export type WidgetLogUncheckedCreateNestedManyWithoutWidgetInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| } | |
| export type WidgetLogUpdateManyWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| upsert?: Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| set?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| delete?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| update?: Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput[] | |
| updateMany?: Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput | Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput[] | |
| deleteMany?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| } | |
| export type WidgetLogUncheckedUpdateManyWithoutWidgetNestedInput = { | |
| create?: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | Prisma.WidgetLogCreateWithoutWidgetInput[] | Prisma.WidgetLogUncheckedCreateWithoutWidgetInput[] | |
| connectOrCreate?: Prisma.WidgetLogCreateOrConnectWithoutWidgetInput | Prisma.WidgetLogCreateOrConnectWithoutWidgetInput[] | |
| upsert?: Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpsertWithWhereUniqueWithoutWidgetInput[] | |
| createMany?: Prisma.WidgetLogCreateManyWidgetInputEnvelope | |
| set?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| disconnect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| delete?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| connect?: Prisma.WidgetLogWhereUniqueInput | Prisma.WidgetLogWhereUniqueInput[] | |
| update?: Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput | Prisma.WidgetLogUpdateWithWhereUniqueWithoutWidgetInput[] | |
| updateMany?: Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput | Prisma.WidgetLogUpdateManyWithWhereWithoutWidgetInput[] | |
| deleteMany?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| } | |
| export type WidgetLogCreateWithoutWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUncheckedCreateWithoutWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogCreateOrConnectWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| create: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type WidgetLogCreateManyWidgetInputEnvelope = { | |
| data: Prisma.WidgetLogCreateManyWidgetInput | Prisma.WidgetLogCreateManyWidgetInput[] | |
| skipDuplicates?: boolean | |
| } | |
| export type WidgetLogUpsertWithWhereUniqueWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| update: Prisma.XOR<Prisma.WidgetLogUpdateWithoutWidgetInput, Prisma.WidgetLogUncheckedUpdateWithoutWidgetInput> | |
| create: Prisma.XOR<Prisma.WidgetLogCreateWithoutWidgetInput, Prisma.WidgetLogUncheckedCreateWithoutWidgetInput> | |
| } | |
| export type WidgetLogUpdateWithWhereUniqueWithoutWidgetInput = { | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateWithoutWidgetInput, Prisma.WidgetLogUncheckedUpdateWithoutWidgetInput> | |
| } | |
| export type WidgetLogUpdateManyWithWhereWithoutWidgetInput = { | |
| where: Prisma.WidgetLogScalarWhereInput | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyWithoutWidgetInput> | |
| } | |
| export type WidgetLogScalarWhereInput = { | |
| AND?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| OR?: Prisma.WidgetLogScalarWhereInput[] | |
| NOT?: Prisma.WidgetLogScalarWhereInput | Prisma.WidgetLogScalarWhereInput[] | |
| id?: Prisma.UuidFilter<"WidgetLog"> | string | |
| oldOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newOptions?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| oldState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| newState?: Prisma.JsonNullableFilter<"WidgetLog"> | |
| widgetId?: Prisma.UuidFilter<"WidgetLog"> | string | |
| createdAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| updatedAt?: Prisma.DateTimeFilter<"WidgetLog"> | Date | string | |
| deletedAt?: Prisma.DateTimeNullableFilter<"WidgetLog"> | Date | string | null | |
| } | |
| export type WidgetLogCreateManyWidgetInput = { | |
| id?: string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Date | string | |
| updatedAt?: Date | string | |
| deletedAt?: Date | string | null | |
| } | |
| export type WidgetLogUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogUncheckedUpdateManyWithoutWidgetInput = { | |
| id?: Prisma.StringFieldUpdateOperationsInput | string | |
| oldOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newOptions?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| oldState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| newState?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue | |
| createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string | |
| deletedAt?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null | |
| } | |
| export type WidgetLogSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{ | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| }, ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogSelectScalar = { | |
| id?: boolean | |
| oldOptions?: boolean | |
| newOptions?: boolean | |
| oldState?: boolean | |
| newState?: boolean | |
| widgetId?: boolean | |
| createdAt?: boolean | |
| updatedAt?: boolean | |
| deletedAt?: boolean | |
| } | |
| export type WidgetLogOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "oldOptions" | "newOptions" | "oldState" | "newState" | "widgetId" | "createdAt" | "updatedAt" | "deletedAt", ExtArgs["result"]["widgetLog"]> | |
| export type WidgetLogInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetLogIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type WidgetLogIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| Widget?: boolean | Prisma.WidgetDefaultArgs<ExtArgs> | |
| } | |
| export type $WidgetLogPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| name: "WidgetLog" | |
| objects: { | |
| Widget: Prisma.$WidgetPayload<ExtArgs> | |
| } | |
| scalars: runtime.Types.Extensions.GetPayloadResult<{ | |
| id: string | |
| oldOptions: runtime.JsonValue | null | |
| newOptions: runtime.JsonValue | null | |
| oldState: runtime.JsonValue | null | |
| newState: runtime.JsonValue | null | |
| widgetId: string | |
| createdAt: Date | |
| updatedAt: Date | |
| deletedAt: Date | null | |
| }, ExtArgs["result"]["widgetLog"]> | |
| composites: {} | |
| } | |
| export type WidgetLogGetPayload<S extends boolean | null | undefined | WidgetLogDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload, S> | |
| export type WidgetLogCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = | |
| Omit<WidgetLogFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & { | |
| select?: WidgetLogCountAggregateInputType | true | |
| } | |
| export interface WidgetLogDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> { | |
| [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['WidgetLog'], meta: { name: 'WidgetLog' } } | |
| /** | |
| * Find zero or one WidgetLog that matches the filter. | |
| * @param {WidgetLogFindUniqueArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findUnique({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUnique<T extends WidgetLogFindUniqueArgs>(args: Prisma.SelectSubset<T, WidgetLogFindUniqueArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find one WidgetLog that matches the filter or throw an error with `error.code='P2025'` | |
| * if no matches were found. | |
| * @param {WidgetLogFindUniqueOrThrowArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findUniqueOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findUniqueOrThrow<T extends WidgetLogFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, WidgetLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first WidgetLog that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindFirstArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findFirst({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirst<T extends WidgetLogFindFirstArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindFirstArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find the first WidgetLog that matches the filter or | |
| * throw `PrismaKnownClientError` with `P2025` code if no matches were found. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindFirstOrThrowArgs} args - Arguments to find a WidgetLog | |
| * @example | |
| * // Get one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.findFirstOrThrow({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| */ | |
| findFirstOrThrow<T extends WidgetLogFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Find zero or more WidgetLogs that matches the filter. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogFindManyArgs} args - Arguments to filter and select certain fields only. | |
| * @example | |
| * // Get all WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany() | |
| * | |
| * // Get first 10 WidgetLogs | |
| * const widgetLogs = await prisma.widgetLog.findMany({ take: 10 }) | |
| * | |
| * // Only select the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.findMany({ select: { id: true } }) | |
| * | |
| */ | |
| findMany<T extends WidgetLogFindManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>> | |
| /** | |
| * Create a WidgetLog. | |
| * @param {WidgetLogCreateArgs} args - Arguments to create a WidgetLog. | |
| * @example | |
| * // Create one WidgetLog | |
| * const WidgetLog = await prisma.widgetLog.create({ | |
| * data: { | |
| * // ... data to create a WidgetLog | |
| * } | |
| * }) | |
| * | |
| */ | |
| create<T extends WidgetLogCreateArgs>(args: Prisma.SelectSubset<T, WidgetLogCreateArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Create many WidgetLogs. | |
| * @param {WidgetLogCreateManyArgs} args - Arguments to create many WidgetLogs. | |
| * @example | |
| * // Create many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.createMany({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| */ | |
| createMany<T extends WidgetLogCreateManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Create many WidgetLogs and returns the data saved in the database. | |
| * @param {WidgetLogCreateManyAndReturnArgs} args - Arguments to create many WidgetLogs. | |
| * @example | |
| * // Create many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.createManyAndReturn({ | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Create many WidgetLogs and only return the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.createManyAndReturn({ | |
| * select: { id: true }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| createManyAndReturn<T extends WidgetLogCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, WidgetLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Delete a WidgetLog. | |
| * @param {WidgetLogDeleteArgs} args - Arguments to delete one WidgetLog. | |
| * @example | |
| * // Delete one WidgetLog | |
| * const WidgetLog = await prisma.widgetLog.delete({ | |
| * where: { | |
| * // ... filter to delete one WidgetLog | |
| * } | |
| * }) | |
| * | |
| */ | |
| delete<T extends WidgetLogDeleteArgs>(args: Prisma.SelectSubset<T, WidgetLogDeleteArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Update one WidgetLog. | |
| * @param {WidgetLogUpdateArgs} args - Arguments to update one WidgetLog. | |
| * @example | |
| * // Update one WidgetLog | |
| * const widgetLog = await prisma.widgetLog.update({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| update<T extends WidgetLogUpdateArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Delete zero or more WidgetLogs. | |
| * @param {WidgetLogDeleteManyArgs} args - Arguments to filter WidgetLogs to delete. | |
| * @example | |
| * // Delete a few WidgetLogs | |
| * const { count } = await prisma.widgetLog.deleteMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * } | |
| * }) | |
| * | |
| */ | |
| deleteMany<T extends WidgetLogDeleteManyArgs>(args?: Prisma.SelectSubset<T, WidgetLogDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more WidgetLogs. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogUpdateManyArgs} args - Arguments to update one or more rows. | |
| * @example | |
| * // Update many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.updateMany({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: { | |
| * // ... provide data here | |
| * } | |
| * }) | |
| * | |
| */ | |
| updateMany<T extends WidgetLogUpdateManyArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload> | |
| /** | |
| * Update zero or more WidgetLogs and returns the data updated in the database. | |
| * @param {WidgetLogUpdateManyAndReturnArgs} args - Arguments to update many WidgetLogs. | |
| * @example | |
| * // Update many WidgetLogs | |
| * const widgetLog = await prisma.widgetLog.updateManyAndReturn({ | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * | |
| * // Update zero or more WidgetLogs and only return the `id` | |
| * const widgetLogWithIdOnly = await prisma.widgetLog.updateManyAndReturn({ | |
| * select: { id: true }, | |
| * where: { | |
| * // ... provide filter here | |
| * }, | |
| * data: [ | |
| * // ... provide data here | |
| * ] | |
| * }) | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * | |
| */ | |
| updateManyAndReturn<T extends WidgetLogUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, WidgetLogUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>> | |
| /** | |
| * Create or update one WidgetLog. | |
| * @param {WidgetLogUpsertArgs} args - Arguments to update or create a WidgetLog. | |
| * @example | |
| * // Update or create a WidgetLog | |
| * const widgetLog = await prisma.widgetLog.upsert({ | |
| * create: { | |
| * // ... data to create a WidgetLog | |
| * }, | |
| * update: { | |
| * // ... in case it already exists, update | |
| * }, | |
| * where: { | |
| * // ... the filter for the WidgetLog we want to update | |
| * } | |
| * }) | |
| */ | |
| upsert<T extends WidgetLogUpsertArgs>(args: Prisma.SelectSubset<T, WidgetLogUpsertArgs<ExtArgs>>): Prisma.Prisma__WidgetLogClient<runtime.Types.Result.GetResult<Prisma.$WidgetLogPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Count the number of WidgetLogs. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogCountArgs} args - Arguments to filter WidgetLogs to count. | |
| * @example | |
| * // Count the number of WidgetLogs | |
| * const count = await prisma.widgetLog.count({ | |
| * where: { | |
| * // ... the filter for the WidgetLogs we want to count | |
| * } | |
| * }) | |
| **/ | |
| count<T extends WidgetLogCountArgs>( | |
| args?: Prisma.Subset<T, WidgetLogCountArgs>, | |
| ): Prisma.PrismaPromise< | |
| T extends runtime.Types.Utils.Record<'select', any> | |
| ? T['select'] extends true | |
| ? number | |
| : Prisma.GetScalarType<T['select'], WidgetLogCountAggregateOutputType> | |
| : number | |
| > | |
| /** | |
| * Allows you to perform aggregations operations on a WidgetLog. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogAggregateArgs} args - Select which aggregations you would like to apply and on what fields. | |
| * @example | |
| * // Ordered by age ascending | |
| * // Where email contains prisma.io | |
| * // Limited to the 10 users | |
| * const aggregations = await prisma.user.aggregate({ | |
| * _avg: { | |
| * age: true, | |
| * }, | |
| * where: { | |
| * email: { | |
| * contains: "prisma.io", | |
| * }, | |
| * }, | |
| * orderBy: { | |
| * age: "asc", | |
| * }, | |
| * take: 10, | |
| * }) | |
| **/ | |
| aggregate<T extends WidgetLogAggregateArgs>(args: Prisma.Subset<T, WidgetLogAggregateArgs>): Prisma.PrismaPromise<GetWidgetLogAggregateType<T>> | |
| /** | |
| * Group by WidgetLog. | |
| * Note, that providing `undefined` is treated as the value not being there. | |
| * Read more here: https://pris.ly/d/null-undefined | |
| * @param {WidgetLogGroupByArgs} args - Group by arguments. | |
| * @example | |
| * // Group by city, order by createdAt, get count | |
| * const result = await prisma.user.groupBy({ | |
| * by: ['city', 'createdAt'], | |
| * orderBy: { | |
| * createdAt: true | |
| * }, | |
| * _count: { | |
| * _all: true | |
| * }, | |
| * }) | |
| * | |
| **/ | |
| groupBy< | |
| T extends WidgetLogGroupByArgs, | |
| HasSelectOrTake extends Prisma.Or< | |
| Prisma.Extends<'skip', Prisma.Keys<T>>, | |
| Prisma.Extends<'take', Prisma.Keys<T>> | |
| >, | |
| OrderByArg extends Prisma.True extends HasSelectOrTake | |
| ? { orderBy: WidgetLogGroupByArgs['orderBy'] } | |
| : { orderBy?: WidgetLogGroupByArgs['orderBy'] }, | |
| OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, | |
| ByFields extends Prisma.MaybeTupleToUnion<T['by']>, | |
| ByValid extends Prisma.Has<ByFields, OrderFields>, | |
| HavingFields extends Prisma.GetHavingFields<T['having']>, | |
| HavingValid extends Prisma.Has<ByFields, HavingFields>, | |
| ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, | |
| InputErrors extends ByEmpty extends Prisma.True | |
| ? `Error: "by" must not be empty.` | |
| : HavingValid extends Prisma.False | |
| ? { | |
| [P in HavingFields]: P extends ByFields | |
| ? never | |
| : P extends string | |
| ? `Error: Field "${P}" used in "having" needs to be provided in "by".` | |
| : [ | |
| Error, | |
| 'Field ', | |
| P, | |
| ` in "having" needs to be provided in "by"`, | |
| ] | |
| }[HavingFields] | |
| : 'take' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "take", you also need to provide "orderBy"' | |
| : 'skip' extends Prisma.Keys<T> | |
| ? 'orderBy' extends Prisma.Keys<T> | |
| ? ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| : 'Error: If you provide "skip", you also need to provide "orderBy"' | |
| : ByValid extends Prisma.True | |
| ? {} | |
| : { | |
| [P in OrderFields]: P extends ByFields | |
| ? never | |
| : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` | |
| }[OrderFields] | |
| >(args: Prisma.SubsetIntersection<T, WidgetLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetWidgetLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors> | |
| /** | |
| * Fields of the WidgetLog model | |
| */ | |
| readonly fields: WidgetLogFieldRefs; | |
| } | |
| /** | |
| * The delegate class that acts as a "Promise-like" for WidgetLog. | |
| * Why is this prefixed with `Prisma__`? | |
| * Because we want to prevent naming conflicts as mentioned in | |
| * https://github.com/prisma/prisma-client-js/issues/707 | |
| */ | |
| export interface Prisma__WidgetLogClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> { | |
| readonly [Symbol.toStringTag]: "PrismaPromise" | |
| Widget<T extends Prisma.WidgetDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.WidgetDefaultArgs<ExtArgs>>): Prisma.Prisma__WidgetClient<runtime.Types.Result.GetResult<Prisma.$WidgetPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions> | |
| /** | |
| * Attaches callbacks for the resolution and/or rejection of the Promise. | |
| * @param onfulfilled The callback to execute when the Promise is resolved. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of which ever callback is executed. | |
| */ | |
| then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2> | |
| /** | |
| * Attaches a callback for only the rejection of the Promise. | |
| * @param onrejected The callback to execute when the Promise is rejected. | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult> | |
| /** | |
| * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The | |
| * resolved value cannot be modified from the callback. | |
| * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). | |
| * @returns A Promise for the completion of the callback. | |
| */ | |
| finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T> | |
| } | |
| /** | |
| * Fields of the WidgetLog model | |
| */ | |
| export interface WidgetLogFieldRefs { | |
| readonly id: Prisma.FieldRef<"WidgetLog", 'String'> | |
| readonly oldOptions: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly newOptions: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly oldState: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly newState: Prisma.FieldRef<"WidgetLog", 'Json'> | |
| readonly widgetId: Prisma.FieldRef<"WidgetLog", 'String'> | |
| readonly createdAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| readonly updatedAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| readonly deletedAt: Prisma.FieldRef<"WidgetLog", 'DateTime'> | |
| } | |
| // Custom InputTypes | |
| /** | |
| * WidgetLog findUnique | |
| */ | |
| export type WidgetLogFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog findUniqueOrThrow | |
| */ | |
| export type WidgetLogFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog findFirst | |
| */ | |
| export type WidgetLogFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of WidgetLogs. | |
| */ | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog findFirstOrThrow | |
| */ | |
| export type WidgetLogFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLog to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for searching for WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} | |
| * | |
| * Filter by unique combinations of WidgetLogs. | |
| */ | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog findMany | |
| */ | |
| export type WidgetLogFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter, which WidgetLogs to fetch. | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} | |
| * | |
| * Determine the order of WidgetLogs to fetch. | |
| */ | |
| orderBy?: Prisma.WidgetLogOrderByWithRelationInput | Prisma.WidgetLogOrderByWithRelationInput[] | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} | |
| * | |
| * Sets the position for listing WidgetLogs. | |
| */ | |
| cursor?: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Take `±n` WidgetLogs from the position of the cursor. | |
| */ | |
| take?: number | |
| /** | |
| * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} | |
| * | |
| * Skip the first `n` WidgetLogs. | |
| */ | |
| skip?: number | |
| distinct?: Prisma.WidgetLogScalarFieldEnum | Prisma.WidgetLogScalarFieldEnum[] | |
| } | |
| /** | |
| * WidgetLog create | |
| */ | |
| export type WidgetLogCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The data needed to create a WidgetLog. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogCreateInput, Prisma.WidgetLogUncheckedCreateInput> | |
| } | |
| /** | |
| * WidgetLog createMany | |
| */ | |
| export type WidgetLogCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to create many WidgetLogs. | |
| */ | |
| data: Prisma.WidgetLogCreateManyInput | Prisma.WidgetLogCreateManyInput[] | |
| skipDuplicates?: boolean | |
| } | |
| /** | |
| * WidgetLog createManyAndReturn | |
| */ | |
| export type WidgetLogCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelectCreateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * The data used to create many WidgetLogs. | |
| */ | |
| data: Prisma.WidgetLogCreateManyInput | Prisma.WidgetLogCreateManyInput[] | |
| skipDuplicates?: boolean | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogIncludeCreateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetLog update | |
| */ | |
| export type WidgetLogUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The data needed to update a WidgetLog. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateInput, Prisma.WidgetLogUncheckedUpdateInput> | |
| /** | |
| * Choose, which WidgetLog to update. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog updateMany | |
| */ | |
| export type WidgetLogUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * The data used to update WidgetLogs. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyInput> | |
| /** | |
| * Filter which WidgetLogs to update | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to update. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * WidgetLog updateManyAndReturn | |
| */ | |
| export type WidgetLogUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelectUpdateManyAndReturn<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * The data used to update WidgetLogs. | |
| */ | |
| data: Prisma.XOR<Prisma.WidgetLogUpdateManyMutationInput, Prisma.WidgetLogUncheckedUpdateManyInput> | |
| /** | |
| * Filter which WidgetLogs to update | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to update. | |
| */ | |
| limit?: number | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogIncludeUpdateManyAndReturn<ExtArgs> | null | |
| } | |
| /** | |
| * WidgetLog upsert | |
| */ | |
| export type WidgetLogUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * The filter to search for the WidgetLog to update in case it exists. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| /** | |
| * In case the WidgetLog found by the `where` argument doesn't exist, create a new WidgetLog with this data. | |
| */ | |
| create: Prisma.XOR<Prisma.WidgetLogCreateInput, Prisma.WidgetLogUncheckedCreateInput> | |
| /** | |
| * In case the WidgetLog was found with the provided `where` argument, update it with this data. | |
| */ | |
| update: Prisma.XOR<Prisma.WidgetLogUpdateInput, Prisma.WidgetLogUncheckedUpdateInput> | |
| } | |
| /** | |
| * WidgetLog delete | |
| */ | |
| export type WidgetLogDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| /** | |
| * Filter which WidgetLog to delete. | |
| */ | |
| where: Prisma.WidgetLogWhereUniqueInput | |
| } | |
| /** | |
| * WidgetLog deleteMany | |
| */ | |
| export type WidgetLogDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Filter which WidgetLogs to delete | |
| */ | |
| where?: Prisma.WidgetLogWhereInput | |
| /** | |
| * Limit how many WidgetLogs to delete. | |
| */ | |
| limit?: number | |
| } | |
| /** | |
| * WidgetLog without action | |
| */ | |
| export type WidgetLogDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = { | |
| /** | |
| * Select specific fields to fetch from the WidgetLog | |
| */ | |
| select?: Prisma.WidgetLogSelect<ExtArgs> | null | |
| /** | |
| * Omit specific fields from the WidgetLog | |
| */ | |
| omit?: Prisma.WidgetLogOmit<ExtArgs> | null | |
| /** | |
| * Choose, which related nodes to fetch as well | |
| */ | |
| include?: Prisma.WidgetLogInclude<ExtArgs> | null | |
| } | |
| ```` | |
| ## File: web/src/server/generated/prisma/browser.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file should be your main import to use Prisma-related types and utilities in a browser. | |
| * Use it to get access to models, enums, and input types. | |
| * | |
| * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only. | |
| * See `client.ts` for the standard, server-side entry point. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import * as Prisma from './internal/prismaNamespaceBrowser' | |
| export { Prisma } | |
| export * as $Enums from './enums' | |
| export * from './enums'; | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type User = Prisma.UserModel | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type Session = Prisma.SessionModel | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type Dashboard = Prisma.DashboardModel | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type Widget = Prisma.WidgetModel | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLog = Prisma.WidgetLogModel | |
| ```` | |
| ## File: web/src/server/generated/prisma/client.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types. | |
| * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import * as processLocal from 'node:process' | |
| import * as path from 'node:path' | |
| import { fileURLToPath } from 'node:url' | |
| globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url)) | |
| import * as runtime from "@prisma/client/runtime/client" | |
| import * as $Enums from "./enums" | |
| import * as $Class from "./internal/class" | |
| import * as Prisma from "./internal/prismaNamespace" | |
| export * as $Enums from './enums' | |
| export * from "./enums" | |
| /** | |
| * ## Prisma Client | |
| * | |
| * Type-safe database client for TypeScript | |
| * @example | |
| * ``` | |
| * const prisma = new PrismaClient() | |
| * // Fetch zero or more Users | |
| * const users = await prisma.user.findMany() | |
| * ``` | |
| * | |
| * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). | |
| */ | |
| export const PrismaClient = $Class.getPrismaClientClass(__dirname) | |
| export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs> | |
| export { Prisma } | |
| /** | |
| * Model User | |
| * | |
| */ | |
| export type User = Prisma.UserModel | |
| /** | |
| * Model Session | |
| * | |
| */ | |
| export type Session = Prisma.SessionModel | |
| /** | |
| * Model Dashboard | |
| * | |
| */ | |
| export type Dashboard = Prisma.DashboardModel | |
| /** | |
| * Model Widget | |
| * | |
| */ | |
| export type Widget = Prisma.WidgetModel | |
| /** | |
| * Model WidgetLog | |
| * | |
| */ | |
| export type WidgetLog = Prisma.WidgetLogModel | |
| ```` | |
| ## File: web/src/server/generated/prisma/commonInputTypes.ts | |
| ````typescript | |
| /* !!! This is code generated by Prisma. Do not edit directly. !!! */ | |
| /* eslint-disable */ | |
| // biome-ignore-all lint: generated file | |
| // @ts-nocheck | |
| /* | |
| * This file exports various common sort, input & filter types that are not directly linked to a particular model. | |
| * | |
| * 🟢 You can import this file directly. | |
| */ | |
| import type * as runtime from "@prisma/client/runtime/client" | |
| import * as $Enums from "./enums" | |
| import type * as Prisma from "./internal/prismaNamespace" | |
| export type UuidFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedUuidFilter<$PrismaModel> | string | |
| } | |
| export type StringNullableFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null | |
| } | |
| export type JsonNullableFilter<$PrismaModel = never> = | |
| | Prisma.PatchUndefined< | |
| Prisma.Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>, | |
| Required<JsonNullableFilterBase<$PrismaModel>> | |
| > | |
| | Prisma.OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>> | |
| export type JsonNullableFilterBase<$PrismaModel = never> = { | |
| equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| path?: string[] | |
| mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel> | |
| string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| } | |
| export type BoolNullableFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableFilter<$PrismaModel> | boolean | null | |
| } | |
| export type DateTimeFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string | |
| } | |
| export type SortOrderInput = { | |
| sort: Prisma.SortOrder | |
| nulls?: Prisma.NullsOrder | |
| } | |
| export type UuidWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedUuidWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type StringNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringNullableFilter<$PrismaModel> | |
| } | |
| export type JsonNullableWithAggregatesFilter<$PrismaModel = never> = | |
| | Prisma.PatchUndefined< | |
| Prisma.Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>, | |
| Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>> | |
| > | |
| | Prisma.OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>> | |
| export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = { | |
| equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| path?: string[] | |
| mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel> | |
| string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null | |
| lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | |
| not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedJsonNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedJsonNullableFilter<$PrismaModel> | |
| } | |
| export type BoolNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedBoolNullableFilter<$PrismaModel> | |
| } | |
| export type DateTimeWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeFilter<$PrismaModel> | |
| } | |
| export type DateTimeNullableFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null | |
| } | |
| export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | |
| } | |
| export type StringFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringFilter<$PrismaModel> | string | |
| } | |
| export type StringWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| mode?: Prisma.QueryMode | |
| not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string | |
| _count?: Prisma.NestedIntFilter<$PrismaModel> | |
| _min?: Prisma.NestedStringFilter<$PrismaModel> | |
| _max?: Prisma.NestedStringFilter<$PrismaModel> | |
| } | |
| export type IntNullableFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null | |
| } | |
| export type IntNullableWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null | |
| in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null | |
| lt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| lte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gt?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| gte?: number | Prisma.IntFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null | |
| _count?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel> | |
| _sum?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _min?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| _max?: Prisma.NestedIntNullableFilter<$PrismaModel> | |
| } | |
| export type NestedUuidFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedUuidFilter<$PrismaModel> | string | |
| } | |
| export type NestedStringNullableFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| contains?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null | |
| } | |
| export type NestedBoolNullableFilter<$PrismaModel = never> = { | |
| equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel> | null | |
| not?: Prisma.NestedBoolNullableFilter<$PrismaModel> | boolean | null | |
| } | |
| export type NestedDateTimeFilter<$PrismaModel = never> = { | |
| equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | |
| lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | |
| not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string | |
| } | |
| export type NestedUuidWithAggregatesFilter<$PrismaModel = never> = { | |
| equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | |
| lt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| lte?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gt?: string | Prisma.StringFieldRefInput<$PrismaModel> | |
| gte?: string | Prisma.StringFieldRefInput<$PrismaModel> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment