fix: build error in Apply method

# Conflicts:
#	pkg/modules/tag/impltag/module.go
#	pkg/modules/tag/tag.go
#	pkg/types/tagtypes/tag_test.go

.github/workflows/build-community.yaml

@@ -54,7 +54,6 @@ jobs:
       JS_SRC: frontend
       JS_OUTPUT_ARTIFACT_CACHE_KEY: community-jsbuild-${{ github.sha }}
       JS_OUTPUT_ARTIFACT_PATH: frontend/build
-      JS_PKG_MANAGER: pnpm
       DOCKER_BUILD: false
       DOCKER_MANIFEST: false
   go-build:

.github/workflows/build-enterprise.yaml

@@ -87,7 +87,6 @@ jobs:
       JS_INPUT_ARTIFACT_PATH: frontend/.env
       JS_OUTPUT_ARTIFACT_CACHE_KEY: enterprise-jsbuild-${{ github.sha }}
       JS_OUTPUT_ARTIFACT_PATH: frontend/build
-      JS_PKG_MANAGER: pnpm
       DOCKER_BUILD: false
       DOCKER_MANIFEST: false
   go-build:

.github/workflows/build-staging.yaml

@@ -86,7 +86,6 @@ jobs:
       JS_INPUT_ARTIFACT_PATH: frontend/.env
       JS_OUTPUT_ARTIFACT_CACHE_KEY: staging-jsbuild-${{ github.sha }}
       JS_OUTPUT_ARTIFACT_PATH: frontend/build
-      JS_PKG_MANAGER: pnpm
       DOCKER_BUILD: false
       DOCKER_MANIFEST: false
   go-build:

.github/workflows/e2eci.yaml

@@ -21,19 +21,15 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: lts/*
-      - name: install-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: install
         run: |
-          cd tests/e2e && pnpm install
+          cd tests/e2e && yarn install --frozen-lockfile
       - name: fmt
         run: |
-          cd tests/e2e && pnpm fmt:check
+          cd tests/e2e && yarn fmt:check
       - name: lint
         run: |
-          cd tests/e2e && pnpm lint
+          cd tests/e2e && yarn lint
   test:
     strategy:
       fail-fast: false
@@ -58,19 +54,15 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: lts/*
-      - name: install-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: python-install
         run: |
           cd tests && uv sync
-      - name: pnpm-install
+      - name: yarn-install
         run: |
-          cd tests/e2e && pnpm install --frozen-lockfile
+          cd tests/e2e && yarn install --frozen-lockfile
       - name: playwright-browsers
         run: |
-          cd tests/e2e && pnpm playwright install --with-deps ${{ matrix.project }}
+          cd tests/e2e && yarn playwright install --with-deps ${{ matrix.project }}
       - name: bring-up-stack
         run: |
           cd tests && \
@@ -81,7 +73,7 @@ jobs:
       - name: playwright-test
         run: |
           cd tests/e2e && \
-            pnpm playwright test --project=${{ matrix.project }}
+            yarn playwright test --project=${{ matrix.project }}
       - name: teardown-stack
         if: always()
         run: |

.github/workflows/goci.yaml

@@ -77,10 +77,6 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: "22"
-      - name: setup-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: docker-community
         shell: bash
         run: |

.github/workflows/gor-signoz-community.yaml

@@ -25,10 +25,6 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: "22"
-      - name: setup-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: build-frontend
         run: make js-build
       - name: upload-frontend-artifact

.github/workflows/gor-signoz.yaml

@@ -41,10 +41,6 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: "22"
-      - name: setup-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: build-frontend
         run: make js-build
       - name: upload-frontend-artifact

.github/workflows/jsci.yaml

@@ -22,7 +22,6 @@ jobs:
     with:
       PRIMUS_REF: main
       JS_SRC: frontend
-      JS_PKG_MANAGER: pnpm
   test:
     if: |
       github.event_name == 'merge_group' ||
@@ -33,7 +32,6 @@ jobs:
     with:
       PRIMUS_REF: main
       JS_SRC: frontend
-      JS_PKG_MANAGER: pnpm
   fmt:
     if: |
       github.event_name == 'merge_group' ||
@@ -44,7 +42,6 @@ jobs:
     with:
       PRIMUS_REF: main
       JS_SRC: frontend
-      JS_PKG_MANAGER: pnpm
   lint:
     if: |
       github.event_name == 'merge_group' ||
@@ -55,7 +52,6 @@ jobs:
     with:
       PRIMUS_REF: main
       JS_SRC: frontend
-      JS_PKG_MANAGER: pnpm
   languages:
     if: |
       github.event_name == 'merge_group' ||
@@ -80,13 +76,9 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: "22"
-      - name: install-pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
       - name: install-frontend
-        run: cd frontend && pnpm install
+        run: cd frontend && yarn install
       - name: generate-api-clients
         run: |
-          cd frontend && pnpm generate:api
-          git diff --compact-summary --exit-code || (echo; echo "Unexpected difference in generated api clients. Run pnpm generate:api in frontend/ locally and commit."; exit 1)
+          cd frontend && yarn generate:api
+          git diff --compact-summary --exit-code || (echo; echo "Unexpected difference in generated api clients. Run yarn generate:api in frontend/ locally and commit."; exit 1)

.gitpod.yml

@@ -1,21 +1,19 @@
 # Please adjust to your needs (see https://www.gitpod.io/docs/config-gitpod-file)
 # and commit this file to your remote git repository to share the goodness with others.
 
+
 tasks:
   - name: Run Docker Images
     init: |
       cd ./deploy/docker
       sudo docker compose up -d
 
-  - name: Install pnpm
-    init: |
-      npm i -g pnpm
-
   - name: Run Frontend
     init: |
       cd ./frontend
-      pnpm install
-    command: pnpm dev
+      yarn install
+    command:
+      yarn dev
 
 ports:
   - port: 8080

Makefile

@@ -154,7 +154,7 @@ $(GO_BUILD_ARCHS_ENTERPRISE_RACE): go-build-enterprise-race-%: $(TARGET_DIR)
 .PHONY: js-build
 js-build: ## Builds the js frontend
 	@echo ">> building js frontend"
-	@cd $(JS_BUILD_CONTEXT) && CI=1 pnpm install && pnpm build
+	@cd $(JS_BUILD_CONTEXT) && CI=1 yarn install && yarn build
 
 ##############################################################
 # docker commands

cmd/community/server.go

@@ -18,19 +18,17 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/gateway/noopgateway"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/licensing/nooplicensing"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
+	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -103,8 +101,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), store, settings, analytics, orgGetter, queryParser, tagModule)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()
@@ -112,9 +110,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(_ licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]] {
 			return signoz.NewAuditorProviderFactories()
 		},
-		func(_ context.Context, _ factory.ProviderSettings, _ flagger.Flagger, _ licensing.Licensing, _ telemetrystore.TelemetryStore, _ retention.Getter, _ organization.Getter, _ zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string) {
-			return signoz.NewMeterReporterProviderFactories(), "noop"
-		},
 		func(ps factory.ProviderSettings, q querier.Querier, a analytics.Analytics) querier.Handler {
 			return querier.NewHandler(ps, q, a)
 		},

cmd/enterprise/Dockerfile.with-web.integration

@@ -3,9 +3,8 @@ FROM node:22-bookworm AS build
 WORKDIR /opt/
 COPY ./frontend/ ./
 ENV NODE_OPTIONS=--max-old-space-size=8192
-RUN CI=1 npm i -g pnpm
-RUN CI=1 pnpm install
-RUN CI=1 pnpm build
+RUN CI=1 yarn install
+RUN CI=1 yarn build
 
 FROM golang:1.25-bookworm
 

cmd/enterprise/meter.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/telemetrylogs"
-	"github.com/SigNoz/signoz/pkg/telemetrymetrics"
-	"github.com/SigNoz/signoz/pkg/telemetrytraces"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-)
-
-var meterConfigs = []metercollector.Config{
-	{
-		Provider: metercollector.ProviderStatic,
-		Static: metercollector.StaticConfig{
-			Name:        zeustypes.MeterPlatformActive,
-			Unit:        zeustypes.MeterUnitCount,
-			Aggregation: zeustypes.MeterAggregationMax,
-			Value:       1,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterLogSize,
-			Unit:                 zeustypes.MeterUnitBytes,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrylogs.DBName,
-			TableName:            telemetrylogs.LogsV2LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultLogsRetentionDays,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterSpanSize,
-			Unit:                 zeustypes.MeterUnitBytes,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrytraces.DBName,
-			TableName:            telemetrytraces.SpanIndexV3LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultTracesRetentionDays,
-		},
-	},
-	{
-		Provider: metercollector.ProviderTelemetry,
-		Telemetry: metercollector.TelemetryConfig{
-			Name:                 zeustypes.MeterDatapointCount,
-			Unit:                 zeustypes.MeterUnitCount,
-			Aggregation:          zeustypes.MeterAggregationSum,
-			DBName:               telemetrymetrics.DBName,
-			TableName:            telemetrymetrics.SamplesV4LocalTableName,
-			DefaultRetentionDays: retentiontypes.DefaultMetricsRetentionDays,
-		},
-	},
-}

cmd/enterprise/server.go

@@ -18,9 +18,6 @@ import (
 	"github.com/SigNoz/signoz/ee/gateway/httpgateway"
 	enterpriselicensing "github.com/SigNoz/signoz/ee/licensing"
 	"github.com/SigNoz/signoz/ee/licensing/httplicensing"
-	"github.com/SigNoz/signoz/ee/metercollector/staticmetercollector"
-	"github.com/SigNoz/signoz/ee/metercollector/telemetrymetercollector"
-	"github.com/SigNoz/signoz/ee/meterreporter/httpmeterreporter"
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/ee/modules/cloudintegration/implcloudintegration/implcloudprovider"
 	"github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard"
@@ -39,17 +36,15 @@ import (
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	pkgflagger "github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/gateway"
 	"github.com/SigNoz/signoz/pkg/global"
 	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
 	"github.com/SigNoz/signoz/pkg/modules/cloudintegration"
 	pkgcloudintegration "github.com/SigNoz/signoz/pkg/modules/cloudintegration/implcloudintegration"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
+	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -151,8 +146,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), store, settings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)
@@ -167,20 +162,6 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return factories
 		},
-		func(ctx context.Context, providerSettings factory.ProviderSettings, flagger pkgflagger.Flagger, licensing licensing.Licensing, telemetryStore telemetrystore.TelemetryStore, retentionGetter retention.Getter, orgGetter organization.Getter, zeus zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string) {
-			factories := signoz.NewMeterReporterProviderFactories()
-
-			collectorFactories := factory.MustNewNamedMap(
-				staticmetercollector.NewFactory(),
-				telemetrymetercollector.NewFactory(telemetryStore, retentionGetter),
-			)
-
-			if err := factories.Add(httpmeterreporter.NewFactory(collectorFactories, meterConfigs, flagger, licensing, orgGetter, zeus)); err != nil {
-				panic(err)
-			}
-
-			return factories, "http"
-		},
 		func(ps factory.ProviderSettings, q querier.Querier, a analytics.Analytics) querier.Handler {
 			communityHandler := querier.NewHandler(ps, q, a)
 			return eequerier.NewHandler(ps, q, communityHandler)

conf/example.yaml

@@ -429,10 +429,3 @@ authz:
   openfga:
     # maximum tuples allowed per openfga write operation.
     max_tuples_per_write: 300
-
-##################### Meter Reporter #####################
-meterreporter:
-  # The interval between collection ticks. Minimum 5m.
-  interval: 6h
-  # Whether to backfill sealed days from the license creation day.
-  backfill: true

docs/contributing/development.md

@@ -13,12 +13,13 @@ Before diving in, make sure you have these tools installed:
   - Download from [go.dev/dl](https://go.dev/dl/)
   - Check [go.mod](../../go.mod#L3) for the minimum version
 
+
 - **Node** - Powers our frontend
   - Download from [nodejs.org](https://nodejs.org)
   - Check [.nvmrc](../../frontend/.nvmrc) for the version
 
-- **Pnpm** - Our frontend package manager
-  - Follow the [installation guide](https://pnpm.io/installation)
+- **Yarn** - Our frontend package manager
+  - Follow the [installation guide](https://yarnpkg.com/getting-started/install)
 
 - **Docker** - For running Clickhouse and Postgres locally
   - Get it from [docs.docker.com/get-docker](https://docs.docker.com/get-docker/)
@@ -94,7 +95,7 @@ This command:
 
 2. Install dependencies:
    ```bash
-   pnpm install
+   yarn install
    ```
 
 3. Create a `.env` file in this directory:
@@ -104,10 +105,10 @@ This command:
 
 4. Start the development server:
    ```bash
-   pnpm dev
+   yarn dev
    ```
 
-> 💡 **Tip**: `pnpm dev` will automatically rebuild when you make changes to the code
+> 💡 **Tip**: `yarn dev` will automatically rebuild when you make changes to the code
 
 Now you're all set to start developing! Happy coding! 🎉
 

docs/contributing/onboarding.md

@@ -304,7 +304,7 @@ import ec2Url from '@/assets/Logos/ec2.svg';
 
 1. Add the logo SVG to `src/assets/Logos/` and add a top-level import in the config file (e.g., `import myServiceUrl from '@/assets/Logos/my-service.svg'`)
 2. Add your data source object to the `onboardingConfigWithLinks` array, referencing the imported variable for `imgUrl`
-3. Test the flow locally with `pnpm dev`
+3. Test the flow locally with `yarn dev`
 4. Validation:
    - Navigate to the [onboarding page](http://localhost:3301/get-started-with-signoz-cloud) on your local machine
    - Data source appears in the list

ee/metercollector/staticmetercollector/provider.go

@@ -1,61 +0,0 @@
-// Package staticmetercollector emits a fixed-value meter reading per org per window.
-package staticmetercollector
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var _ metercollector.MeterCollector = (*Provider)(nil)
-
-type Provider struct {
-	settings factory.ScopedProviderSettings
-	config   metercollector.StaticConfig
-}
-
-func NewFactory() factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(metercollector.ProviderStatic), func(ctx context.Context, providerSettings factory.ProviderSettings, config metercollector.Config) (metercollector.MeterCollector, error) {
-		return newProvider(providerSettings, config.Static), nil
-	},
-	)
-}
-
-func newProvider(providerSettings factory.ProviderSettings, config metercollector.StaticConfig) *Provider {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/metercollector/staticmetercollector")
-
-	return &Provider{
-		settings: settings,
-		config:   config,
-	}
-}
-
-func (provider *Provider) Name() zeustypes.MeterName { return provider.config.Name }
-func (provider *Provider) Unit() zeustypes.MeterUnit { return provider.config.Unit }
-func (provider *Provider) Aggregation() zeustypes.MeterAggregation {
-	return provider.config.Aggregation
-}
-
-func (provider *Provider) Origin(_ context.Context, _ valuer.UUID, license *licensetypes.License, _ time.Time) (time.Time, error) {
-	if license == nil || license.CreatedAt.IsZero() {
-		return time.Time{}, nil
-	}
-
-	createdAt := license.CreatedAt.UTC()
-	return time.Date(createdAt.Year(), createdAt.Month(), createdAt.Day(), 0, 0, 0, 0, time.UTC), nil
-}
-
-func (provider *Provider) Collect(_ context.Context, orgID valuer.UUID, license *licensetypes.License, window zeustypes.MeterWindow) ([]zeustypes.Meter, error) {
-	if license == nil || license.Key == "" {
-		return nil, nil
-	}
-
-	return []zeustypes.Meter{
-		zeustypes.NewMeter(provider.config.Name, provider.config.Value, provider.config.Unit, provider.config.Aggregation, window, zeustypes.NewDimensions(zeustypes.OrganizationID.String(orgID.StringValue()))),
-	}, nil
-}

ee/metercollector/telemetrymetercollector/provider.go

@@ -1,247 +0,0 @@
-// Package telemetrymetercollector collects telemetry meters (logs, traces, metrics)
-// by retention. One Provider materializes per TelemetryConfig.
-package telemetrymetercollector
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/huandu/go-sqlbuilder"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/modules/retention"
-	"github.com/SigNoz/signoz/pkg/telemetrymeter"
-	"github.com/SigNoz/signoz/pkg/telemetrystore"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/retentiontypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-var (
-	labelKeyPattern   = regexp.MustCompile(`^[A-Za-z0-9_.\-]+$`)
-	labelValuePattern = regexp.MustCompile(`^[A-Za-z0-9_.\-:]+$`)
-)
-
-var _ metercollector.MeterCollector = (*Provider)(nil)
-
-type Provider struct {
-	settings        factory.ScopedProviderSettings
-	config          metercollector.TelemetryConfig
-	telemetryStore  telemetrystore.TelemetryStore
-	retentionGetter retention.Getter
-}
-
-func NewFactory(telemetryStore telemetrystore.TelemetryStore, retentionGetter retention.Getter) factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config] {
-	return factory.NewProviderFactory(factory.MustNewName(metercollector.ProviderTelemetry), func(ctx context.Context, providerSettings factory.ProviderSettings, config metercollector.Config) (metercollector.MeterCollector, error) {
-		return newProvider(providerSettings, config.Telemetry, telemetryStore, retentionGetter), nil
-	},
-	)
-}
-
-func newProvider(
-	providerSettings factory.ProviderSettings,
-	config metercollector.TelemetryConfig,
-	telemetryStore telemetrystore.TelemetryStore,
-	retentionGetter retention.Getter,
-) *Provider {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/metercollector/telemetrymetercollector")
-
-	return &Provider{
-		settings:        settings,
-		config:          config,
-		telemetryStore:  telemetryStore,
-		retentionGetter: retentionGetter,
-	}
-}
-
-func (provider *Provider) Name() zeustypes.MeterName { return provider.config.Name }
-func (provider *Provider) Unit() zeustypes.MeterUnit { return provider.config.Unit }
-func (provider *Provider) Aggregation() zeustypes.MeterAggregation {
-	return provider.config.Aggregation
-}
-
-func (provider *Provider) Origin(ctx context.Context, _ valuer.UUID, _ *licensetypes.License, todayStart time.Time) (time.Time, error) {
-	query, args := buildOriginQuery(provider.config.Name.String())
-
-	var minMs int64
-	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, query, args...).Scan(&minMs); err != nil {
-		return time.Time{}, err
-	}
-	if minMs == 0 {
-		return todayStart, nil
-	}
-
-	minDay := time.UnixMilli(minMs).UTC()
-	return time.Date(minDay.Year(), minDay.Month(), minDay.Day(), 0, 0, 0, 0, time.UTC), nil
-}
-
-func (provider *Provider) Collect(
-	ctx context.Context,
-	orgID valuer.UUID,
-	_ *licensetypes.License,
-	window zeustypes.MeterWindow,
-) ([]zeustypes.Meter, error) {
-	meterName := provider.config.Name.String()
-
-	segments, err := provider.retentionGetter.GetRetentionPolicySegments(
-		ctx,
-		orgID,
-		provider.config.DBName,
-		provider.config.TableName,
-		provider.config.DefaultRetentionDays,
-		window.StartUnixMilli,
-		window.EndUnixMilli,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	valuesByRetentionDays := make(map[int]int64)
-
-	for _, segment := range segments {
-		query, args, err := buildQuery(meterName, segment)
-		if err != nil {
-			return nil, err
-		}
-
-		rows, err := provider.telemetryStore.ClickhouseDB().Query(ctx, query, args...)
-		if err != nil {
-			return nil, err
-		}
-
-		if err := func() error {
-			defer rows.Close()
-			for rows.Next() {
-				var retentionDays int32
-				var value int64
-
-				if err := rows.Scan(&retentionDays, &value); err != nil {
-					return err
-				}
-
-				valuesByRetentionDays[int(retentionDays)] += value
-			}
-			if err := rows.Err(); err != nil {
-				return err
-			}
-			return nil
-		}(); err != nil {
-			return nil, err
-		}
-	}
-
-	meters := make([]zeustypes.Meter, 0, len(valuesByRetentionDays))
-	for retentionDays, value := range valuesByRetentionDays {
-		meters = append(meters, zeustypes.NewMeter(provider.config.Name, value, provider.config.Unit, provider.config.Aggregation, window, buildDimensions(orgID, retentionDays)))
-	}
-
-	// Empty windows still emit a sentinel so checkpoints can advance.
-	if len(meters) == 0 && len(segments) > 0 {
-		meters = append(meters, zeustypes.NewMeter(provider.config.Name, 0, provider.config.Unit, provider.config.Aggregation, window, buildDimensions(orgID, segments[len(segments)-1].DefaultDays)))
-	}
-
-	return meters, nil
-}
-
-func buildOriginQuery(meterName string) (string, []any) {
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select("toInt64(ifNull(min(unix_milli), 0))")
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
-	sb.Where(sb.Equal("metric_name", meterName))
-	return sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-}
-
-func buildQuery(meterName string, segment *retentiontypes.RetentionPolicySegment) (string, []any, error) {
-	retentionExpr, err := buildRetentionMultiIfSQL(segment.Rules, segment.DefaultDays)
-	if err != nil {
-		return "", nil, err
-	}
-
-	selects := []string{
-		retentionExpr + " AS retention_days",
-		"toInt64(ifNull(sum(value), 0)) AS value",
-	}
-
-	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(selects...)
-	sb.From(telemetrymeter.DBName + "." + telemetrymeter.SamplesTableName)
-	sb.Where(
-		sb.Equal("metric_name", meterName),
-		sb.GTE("unix_milli", segment.StartMs),
-		sb.LT("unix_milli", segment.EndMs),
-	)
-	sb.GroupBy("retention_days")
-	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
-	return query, args, nil
-}
-
-func buildRetentionMultiIfSQL(rules []retentiontypes.CustomRetentionRule, defaultDays int) (string, error) {
-	if defaultDays <= 0 {
-		return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "non-positive default retention %d", defaultDays)
-	}
-
-	if len(rules) == 0 {
-		return "toInt32(" + strconv.Itoa(defaultDays) + ")", nil
-	}
-
-	arms := make([]string, 0, 2*len(rules)+1)
-	for ruleIndex, rule := range rules {
-		if rule.TTLDays <= 0 {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d has non-positive ttl_days %d", ruleIndex, rule.TTLDays)
-		}
-		conditionExpr, err := buildRuleConditionSQL(ruleIndex, rule)
-		if err != nil {
-			return "", err
-		}
-
-		arms = append(arms, conditionExpr)
-		arms = append(arms, strconv.Itoa(rule.TTLDays))
-	}
-	arms = append(arms, strconv.Itoa(defaultDays))
-
-	return "toInt32(multiIf(" + strings.Join(arms, ", ") + "))", nil
-}
-
-func buildRuleConditionSQL(ruleIndex int, rule retentiontypes.CustomRetentionRule) (string, error) {
-	if len(rule.Filters) == 0 {
-		return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d has no filters", ruleIndex)
-	}
-
-	filterExprs := make([]string, 0, len(rule.Filters))
-	for filterIndex, filter := range rule.Filters {
-		if !labelKeyPattern.MatchString(filter.Key) {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d has invalid key %q", ruleIndex, filterIndex, filter.Key)
-		}
-		if len(filter.Values) == 0 {
-			return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d has no values", ruleIndex, filterIndex)
-		}
-
-		quoted := make([]string, len(filter.Values))
-		for valueIndex, value := range filter.Values {
-			if !labelValuePattern.MatchString(value) {
-				return "", errors.Newf(errors.TypeInvalidInput, metercollector.ErrCodeMeterCollectorInvalidCustomRetentionRule, "rule %d filter %d value %d is invalid %q", ruleIndex, filterIndex, valueIndex, value)
-			}
-			quoted[valueIndex] = "'" + value + "'"
-		}
-
-		filterExprs = append(filterExprs, fmt.Sprintf("JSONExtractString(labels, '%s') IN (%s)", filter.Key, strings.Join(quoted, ", ")))
-	}
-
-	return strings.Join(filterExprs, " AND "), nil
-}
-
-func buildDimensions(orgID valuer.UUID, retentionDays int) map[string]string {
-	retentionDurationSeconds := int64(retentionDays) * 24 * 60 * 60 // seconds
-
-	return zeustypes.NewDimensions(
-		zeustypes.OrganizationID.String(orgID.StringValue()),
-		zeustypes.RetentionDuration.String(strconv.FormatInt(retentionDurationSeconds, 10)),
-	)
-}

ee/meterreporter/httpmeterreporter/provider.go

@@ -1,318 +0,0 @@
-package httpmeterreporter
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/flagger"
-	"github.com/SigNoz/signoz/pkg/licensing"
-	"github.com/SigNoz/signoz/pkg/metercollector"
-	"github.com/SigNoz/signoz/pkg/meterreporter"
-	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/featuretypes"
-	"github.com/SigNoz/signoz/pkg/types/licensetypes"
-	"github.com/SigNoz/signoz/pkg/types/zeustypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/SigNoz/signoz/pkg/zeus"
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/trace"
-)
-
-var _ factory.ServiceWithHealthy = (*Provider)(nil)
-
-type Provider struct {
-	settings         factory.ScopedProviderSettings
-	config           meterreporter.Config
-	collectorsByName map[zeustypes.MeterName]metercollector.MeterCollector
-	flagger          flagger.Flagger
-	licensing        licensing.Licensing
-	orgGetter        organization.Getter
-	zeus             zeus.Zeus
-	healthyC         chan struct{}
-	stopC            chan struct{}
-	metrics          *reporterMetrics
-}
-
-func NewFactory(collectorFactories factory.NamedMap[factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config]], collectorConfigs []metercollector.Config, flagger flagger.Flagger, licensing licensing.Licensing, orgGetter organization.Getter, zeus zeus.Zeus) factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config] {
-	return factory.NewProviderFactory(factory.MustNewName("http"), func(ctx context.Context, providerSettings factory.ProviderSettings, config meterreporter.Config) (meterreporter.Reporter, error) {
-		return newProvider(ctx, providerSettings, config, collectorFactories, collectorConfigs, flagger, licensing, orgGetter, zeus)
-	},
-	)
-}
-
-func newProvider(
-	ctx context.Context,
-	providerSettings factory.ProviderSettings,
-	config meterreporter.Config,
-	collectorFactories factory.NamedMap[factory.ProviderFactory[metercollector.MeterCollector, metercollector.Config]],
-	collectorConfigs []metercollector.Config,
-	flagger flagger.Flagger,
-	licensing licensing.Licensing,
-	orgGetter organization.Getter,
-	zeus zeus.Zeus,
-) (*Provider, error) {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/ee/meterreporter/httpmeterreporter")
-
-	collectorsByName := map[zeustypes.MeterName]metercollector.MeterCollector{}
-	for _, collectorConfig := range collectorConfigs {
-		collector, err := factory.NewProviderFromNamedMap(ctx, providerSettings, collectorConfig, collectorFactories, collectorConfig.Provider)
-		if err != nil {
-			return nil, err
-		}
-		if _, exists := collectorsByName[collector.Name()]; exists {
-			return nil, errors.Newf(errors.TypeAlreadyExists, errors.CodeAlreadyExists, "duplicate meter collector %q", collector.Name())
-		}
-		collectorsByName[collector.Name()] = collector
-	}
-
-	metrics, err := newReporterMetrics(settings.Meter())
-	if err != nil {
-		return nil, err
-	}
-
-	return &Provider{
-		settings:         settings,
-		config:           config,
-		collectorsByName: collectorsByName,
-		flagger:          flagger,
-		licensing:        licensing,
-		orgGetter:        orgGetter,
-		zeus:             zeus,
-		healthyC:         make(chan struct{}),
-		stopC:            make(chan struct{}),
-		metrics:          metrics,
-	}, nil
-}
-
-func (provider *Provider) Start(ctx context.Context) error {
-	close(provider.healthyC)
-
-	provider.collect(ctx)
-
-	ticker := time.NewTicker(provider.config.Interval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-provider.stopC:
-			return nil
-		case <-ticker.C:
-			provider.collect(ctx)
-		}
-	}
-}
-
-func (provider *Provider) collect(ctx context.Context) {
-	ctx, span := provider.settings.Tracer().Start(ctx, "meterreporter.Collect", trace.WithAttributes(attribute.String("meterreporter.provider", "http")))
-	defer span.End()
-
-	orgs, err := provider.orgGetter.ListByOwnedKeyRange(ctx)
-	if err != nil {
-		span.RecordError(err)
-		provider.settings.Logger().ErrorContext(ctx, "failed to get orgs data", errors.Attr(err))
-		return
-	}
-
-	for _, org := range orgs {
-		evalCtx := featuretypes.NewFlaggerEvaluationContext(org.ID)
-		if !provider.flagger.BooleanOrEmpty(ctx, flagger.FeatureUseMeterReporter, evalCtx) {
-			provider.settings.Logger().DebugContext(ctx, "meter reporter disabled for org, skipping reporting", slog.String("org_id", org.ID.StringValue()))
-			continue
-		}
-
-		license, err := provider.licensing.GetActive(ctx, org.ID)
-		if err != nil {
-			if errors.Ast(err, errors.TypeNotFound) {
-				provider.settings.Logger().DebugContext(ctx, "no active license found for org, skipping reporting", slog.String("org_id", org.ID.StringValue()))
-				continue
-			}
-
-			span.RecordError(err)
-			provider.settings.Logger().ErrorContext(ctx, "failed to fetch active license for org", errors.Attr(err), slog.String("org_id", org.ID.StringValue()))
-			return
-		}
-
-		if err := provider.collectOrg(ctx, org, license); err != nil {
-			span.RecordError(err)
-			provider.settings.Logger().ErrorContext(ctx, "failed to collect meters", errors.Attr(err), slog.String("org_id", org.ID.StringValue()))
-		}
-	}
-}
-
-func (provider *Provider) Stop(ctx context.Context) error {
-	close(provider.stopC)
-	return nil
-}
-
-func (provider *Provider) Healthy() <-chan struct{} {
-	return provider.healthyC
-}
-
-func (provider *Provider) collectOrg(ctx context.Context, org *types.Organization, license *licensetypes.License) error {
-	now := time.Now().UTC()
-	// Use one timestamp so a tick cannot straddle midnight.
-	todayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
-
-	if provider.config.Backfill {
-		checkpointsByMeter, err := provider.checkpoints(ctx, license.Key)
-		if err != nil {
-			return err
-		}
-
-		nextByCollector := provider.nextDays(license, todayStart, checkpointsByMeter)
-
-		start, end, ok := backfillRange(nextByCollector, todayStart)
-		if ok {
-			for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
-				eligible := eligibleCollectors(provider.collectorsByName, nextByCollector, day)
-				if len(eligible) == 0 {
-					continue
-				}
-
-				window, err := zeustypes.NewMeterWindow(day.UnixMilli(), day.AddDate(0, 0, 1).UnixMilli(), true)
-				if err != nil {
-					return err
-				}
-
-				if err := provider.report(ctx, org.ID, license, window, eligible); err != nil {
-					provider.settings.Logger().WarnContext(ctx, "failed to backfill for day", errors.Attr(err), slog.String("date", day.Format("2006-01-02")))
-					return err
-				}
-			}
-		}
-	}
-
-	// Today's partial window: every collector is always eligible (next <= today).
-	if now.UnixMilli() > todayStart.UnixMilli() {
-		todayWindow, err := zeustypes.NewMeterWindow(todayStart.UnixMilli(), now.UnixMilli(), false)
-		if err != nil {
-			return err
-		}
-
-		return provider.report(ctx, org.ID, license, todayWindow, provider.collectorsByName)
-	}
-
-	return nil
-}
-
-func (provider *Provider) checkpoints(ctx context.Context, licenseKey string) (map[string]time.Time, error) {
-	list, err := provider.zeus.ListMeterCheckpoints(ctx, licenseKey)
-	if err != nil {
-		provider.metrics.checkpoints.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return nil, err
-	}
-
-	provider.metrics.checkpoints.Add(ctx, 1)
-
-	checkpointsByMeter := make(map[string]time.Time, len(list))
-	for _, checkpoint := range list {
-		checkpointsByMeter[checkpoint.Name] = checkpoint.StartDate.UTC()
-	}
-
-	return checkpointsByMeter, nil
-}
-
-func (provider *Provider) nextDays(license *licensetypes.License, todayStart time.Time, checkpointsByMeter map[string]time.Time) map[zeustypes.MeterName]time.Time {
-	nextByCollector := make(map[zeustypes.MeterName]time.Time, len(provider.collectorsByName))
-	licenseCreatedAt := license.CreatedAt.UTC()
-	licenseCreatedAtDay := time.Date(licenseCreatedAt.Year(), licenseCreatedAt.Month(), licenseCreatedAt.Day(), 0, 0, 0, 0, time.UTC)
-
-	for _, collector := range provider.collectorsByName {
-		checkpoint, hasCheckpoint := checkpointsByMeter[collector.Name().String()]
-		nextByCollector[collector.Name()] = nextReportableDay(licenseCreatedAtDay, todayStart, checkpoint, hasCheckpoint)
-	}
-
-	return nextByCollector
-}
-
-func nextReportableDay(licenseCreatedAtDay time.Time, todayStart time.Time, checkpoint time.Time, hasCheckpoint bool) time.Time {
-	next := licenseCreatedAtDay
-	if next.IsZero() {
-		next = todayStart
-	}
-
-	if hasCheckpoint {
-		checkpointNext := checkpoint.AddDate(0, 0, 1)
-		if checkpointNext.After(next) {
-			next = checkpointNext
-		}
-	}
-
-	return next
-}
-
-func (provider *Provider) report(ctx context.Context, orgID valuer.UUID, license *licensetypes.License, window zeustypes.MeterWindow, collectors map[zeustypes.MeterName]metercollector.MeterCollector) error {
-	date := time.UnixMilli(window.StartUnixMilli).UTC().Format("2006-01-02")
-
-	meters := make([]zeustypes.Meter, 0, len(collectors))
-	for _, collector := range collectors {
-		meterAttr := attribute.String("signoz.meter.name", collector.Name().String())
-		collectedReadings, err := collector.Collect(ctx, orgID, license, window)
-		if err != nil {
-			provider.metrics.collections.Add(ctx, 1, metric.WithAttributes(meterAttr, errors.TypeAttr(err)))
-			continue
-		}
-
-		provider.metrics.collections.Add(ctx, 1, metric.WithAttributes(meterAttr))
-		meters = append(meters, collectedReadings...)
-	}
-
-	if len(meters) == 0 {
-		return nil
-	}
-
-	idempotencyKey := fmt.Sprintf("meterreporter:%s", date)
-
-	body, err := json.Marshal(meters)
-	if err != nil {
-		provider.metrics.reports.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return err
-	}
-
-	if err := provider.zeus.PutMetersV3(ctx, license.Key, idempotencyKey, body); err != nil {
-		provider.metrics.reports.Add(ctx, 1, metric.WithAttributes(errors.TypeAttr(err)))
-		return err
-	}
-
-	provider.metrics.reports.Add(ctx, 1)
-	provider.metrics.meters.Add(ctx, int64(len(meters)))
-	return nil
-}
-
-// backfillRange returns the inclusive sealed-day range ending at yesterday.
-func backfillRange(nextByCollector map[zeustypes.MeterName]time.Time, todayStart time.Time) (start, end time.Time, ok bool) {
-	yesterday := todayStart.AddDate(0, 0, -1)
-
-	for _, next := range nextByCollector {
-		if !next.Before(todayStart) {
-			continue
-		}
-		if start.IsZero() || next.Before(start) {
-			start = next
-		}
-	}
-
-	if start.IsZero() || start.After(yesterday) {
-		return time.Time{}, time.Time{}, false
-	}
-
-	return start, yesterday, true
-}
-
-func eligibleCollectors(collectors map[zeustypes.MeterName]metercollector.MeterCollector, nextByCollector map[zeustypes.MeterName]time.Time, day time.Time) map[zeustypes.MeterName]metercollector.MeterCollector {
-	eligible := make(map[zeustypes.MeterName]metercollector.MeterCollector, len(collectors))
-	for name, collector := range collectors {
-		if !nextByCollector[name].After(day) {
-			eligible[name] = collector
-		}
-	}
-
-	return eligible
-}

ee/meterreporter/httpmeterreporter/telemetry.go

@@ -1,48 +0,0 @@
-package httpmeterreporter
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"go.opentelemetry.io/otel/metric"
-)
-
-type reporterMetrics struct {
-	checkpoints metric.Int64Counter
-	reports     metric.Int64Counter
-	collections metric.Int64Counter
-	meters      metric.Int64Counter
-}
-
-func newReporterMetrics(meter metric.Meter) (*reporterMetrics, error) {
-	var errs error
-
-	checkpoints, err := meter.Int64Counter("signoz.meterreporter.checkpoints", metric.WithDescription("Zeus meter checkpoint fetches."), metric.WithUnit("{checkpoint}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	reports, err := meter.Int64Counter("signoz.meterreporter.reports", metric.WithDescription("Meter reports shipped to Zeus."), metric.WithUnit("{report}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	collections, err := meter.Int64Counter("signoz.meterreporter.collections", metric.WithDescription("Per-meter collect calls."), metric.WithUnit("{collection}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	meters, err := meter.Int64Counter("signoz.meterreporter.meters", metric.WithDescription("Meter readings shipped to Zeus."), metric.WithUnit("{meter}"))
-	if err != nil {
-		errs = errors.Join(errs, err)
-	}
-
-	if errs != nil {
-		return nil, errs
-	}
-
-	return &reporterMetrics{
-		checkpoints: checkpoints,
-		reports:     reports,
-		collections: collections,
-		meters:      meters,
-	}, nil
-}

ee/modules/dashboard/impldashboard/module.go

@@ -11,8 +11,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
+	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
@@ -30,9 +32,9 @@ type module struct {
 	licensing          licensing.Licensing
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+func NewModule(store dashboardtypes.Store, sqlstore sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, sqlstore, settings, analytics, orgGetter, queryParser, tagModule)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -197,6 +199,68 @@ func (module *module) Create(ctx context.Context, orgID valuer.UUID, createdBy s
 	return module.pkgDashboardModule.Create(ctx, orgID, createdBy, creator, data)
 }
 
+func (module *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
+	return module.pkgDashboardModule.CreateV2(ctx, orgID, createdBy, creator, postable)
+}
+
+func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
+	return module.pkgDashboardModule.GetV2(ctx, orgID, id)
+}
+
+func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error) {
+	return module.pkgDashboardModule.UpdateV2(ctx, orgID, id, updatedBy, updateable)
+}
+
+func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
+	return module.pkgDashboardModule.PatchV2(ctx, orgID, id, updatedBy, patch)
+}
+
+func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
+	return module.pkgDashboardModule.LockUnlockV2(ctx, orgID, id, updatedBy, isAdmin, lock)
+}
+
+func (module *module) CreatePublicV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, postable dashboardtypes.PostablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
+	if _, err := module.licensing.GetActive(ctx, orgID); err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	existing, err := module.pkgDashboardModule.GetV2(ctx, orgID, id)
+	if err != nil {
+		return nil, err
+	}
+	if existing.PublicConfig != nil {
+		return nil, errors.Newf(errors.TypeAlreadyExists, dashboardtypes.ErrCodePublicDashboardAlreadyExists, "dashboard with id %s is already public", id)
+	}
+
+	publicDashboard := dashboardtypes.NewPublicDashboard(postable.TimeRangeEnabled, postable.DefaultTimeRange, id)
+	if err := module.store.CreatePublic(ctx, dashboardtypes.NewStorablePublicDashboardFromPublicDashboard(publicDashboard)); err != nil {
+		return nil, err
+	}
+
+	existing.PublicConfig = publicDashboard
+	return existing, nil
+}
+
+func (module *module) UpdatePublicV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatable dashboardtypes.UpdatablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
+	if _, err := module.licensing.GetActive(ctx, orgID); err != nil {
+		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
+	}
+
+	existing, err := module.pkgDashboardModule.GetV2(ctx, orgID, id)
+	if err != nil {
+		return nil, err
+	}
+	if existing.PublicConfig == nil {
+		return nil, errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodePublicDashboardNotFound, "dashboard with id %s isn't public", id)
+	}
+
+	existing.PublicConfig.Update(updatable.TimeRangeEnabled, updatable.DefaultTimeRange)
+	if err := module.store.UpdatePublic(ctx, dashboardtypes.NewStorablePublicDashboardFromPublicDashboard(existing.PublicConfig)); err != nil {
+		return nil, err
+	}
+	return existing, nil
+}
+
 func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.Get(ctx, orgID, id)
 }

ee/query-service/app/server.go

@@ -114,7 +114,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 	// initiate agent config handler
 	agentConfMgr, err := agentConf.Initiate(&agentConf.ManagerOptions{
 		Store:         signoz.SQLStore,
-		AgentFeatures: []agentConf.AgentFeature{logParsingPipelineController, signoz.Modules.LLMPricingRule},
+		AgentFeatures: []agentConf.AgentFeature{logParsingPipelineController},
 	})
 	if err != nil {
 		return nil, err

ee/zeus/httpzeus/provider.go

@@ -150,72 +150,6 @@ func (provider *Provider) PutMetersV2(ctx context.Context, key string, data []by
 	return err
 }
 
-func (provider *Provider) PutMetersV3(ctx context.Context, key string, idempotencyKey string, data []byte) error {
-	headers := http.Header{}
-	if idempotencyKey != "" {
-		headers.Set("X-Idempotency-Key", idempotencyKey)
-	}
-
-	_, err := provider.doWithHeaders(
-		ctx,
-		provider.config.URL.JoinPath("/v2/meters"),
-		http.MethodPost,
-		key,
-		data,
-		headers,
-	)
-
-	return err
-}
-
-func (provider *Provider) ListMeterCheckpoints(ctx context.Context, key string) ([]zeustypes.MeterCheckpoint, error) {
-	response, err := provider.do(
-		ctx,
-		provider.config.URL.JoinPath("/v2/meters/checkpoints"),
-		http.MethodGet,
-		key,
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	checkpointValues := gjson.GetBytes(response, "data")
-	if !checkpointValues.Exists() || checkpointValues.Type == gjson.Null {
-		return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoints are required")
-	}
-
-	if !checkpointValues.IsArray() {
-		return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoints must be an array")
-	}
-
-	checkpointResults := checkpointValues.Array()
-	checkpoints := make([]zeustypes.MeterCheckpoint, 0, len(checkpointResults))
-	for _, checkpointValue := range checkpointResults {
-		name := checkpointValue.Get("name").String()
-		if name == "" {
-			return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoint name is required")
-		}
-
-		startDateString := checkpointValue.Get("start_date").String()
-		if startDateString == "" {
-			return nil, errors.Newf(errors.TypeInternal, zeus.ErrCodeResponseMalformed, "meter checkpoint start_date is required for %q", name)
-		}
-
-		startDate, err := time.Parse("2006-01-02", startDateString)
-		if err != nil {
-			return nil, errors.Wrapf(err, errors.TypeInternal, zeus.ErrCodeResponseMalformed, "parse meter checkpoint start_date %q for %q", startDateString, name)
-		}
-
-		checkpoints = append(checkpoints, zeustypes.MeterCheckpoint{
-			Name:      name,
-			StartDate: startDate,
-		})
-	}
-
-	return checkpoints, nil
-}
-
 func (provider *Provider) PutProfile(ctx context.Context, key string, profile *zeustypes.PostableProfile) error {
 	body, err := json.Marshal(profile)
 	if err != nil {
@@ -251,21 +185,12 @@ func (provider *Provider) PutHost(ctx context.Context, key string, host *zeustyp
 }
 
 func (provider *Provider) do(ctx context.Context, url *url.URL, method string, key string, requestBody []byte) ([]byte, error) {
-	return provider.doWithHeaders(ctx, url, method, key, requestBody, nil)
-}
-
-func (provider *Provider) doWithHeaders(ctx context.Context, url *url.URL, method string, key string, requestBody []byte, extraHeaders http.Header) ([]byte, error) {
 	request, err := http.NewRequestWithContext(ctx, method, url.String(), bytes.NewBuffer(requestBody))
 	if err != nil {
 		return nil, err
 	}
 	request.Header.Set("X-Signoz-Cloud-Api-Key", key)
 	request.Header.Set("Content-Type", "application/json")
-	for k, vs := range extraHeaders {
-		for _, v := range vs {
-			request.Header.Add(k, v)
-		}
-	}
 
 	response, err := provider.httpClient.Do(request)
 	if err != nil {

frontend/.husky/commit-msg

@@ -1,7 +1,7 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-cd frontend && pnpm run commitlint --edit $1
+cd frontend && yarn run commitlint --edit $1
 
 branch="$(git rev-parse --abbrev-ref HEAD)"
 

frontend/.husky/pre-commit

@@ -1,4 +1,4 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-cd frontend && pnpm lint-staged
+cd frontend && yarn lint-staged

frontend/.npmrc

@@ -1,4 +1 @@
-registry = 'https://registry.npmjs.org/'
-
-public-hoist-pattern[]=@commitlint*
-public-hoist-pattern[]=commitlint
+registry = 'https://registry.npmjs.org/'

frontend/.oxlintrc.json

@@ -411,7 +411,7 @@
     "jsx-a11y/media-has-caption": "warn",
     "jsx-a11y/mouse-events-have-key-events": "warn",
     "jsx-a11y/no-access-key": "error",
-    "jsx-a11y/no-autofocus": "off",
+    "jsx-a11y/no-autofocus": "warn",
     "jsx-a11y/no-distracting-elements": "error",
     "jsx-a11y/no-redundant-roles": "warn",
     "jsx-a11y/role-has-required-aria-props": "warn",

frontend/README.md

@@ -28,8 +28,8 @@ Follow the steps below
 1. ```git clone https://github.com/SigNoz/signoz.git && cd signoz/frontend```
 1. change baseURL to ```<test environment URL>``` in file ```src/constants/env.ts```
 
-1. ```pnpm install```
-1. ```pnpm dev```
+1. ```yarn install```
+1. ```yarn dev```
 
 ```Note: Please ping us in #contributing channel in our slack community and we will DM you with <test environment URL>```
 
@@ -41,7 +41,7 @@ This project was bootstrapped with [Create React App](https://github.com/faceboo
 
 In the project directory, you can run:
 
-### `pnpm start`
+### `yarn start`
 
 Runs the app in the development mode.\
 Open [http://localhost:3301](http://localhost:3301) to view it in the browser.
@@ -49,12 +49,12 @@ Open [http://localhost:3301](http://localhost:3301) to view it in the browser.
 The page will reload if you make edits.\
 You will also see any lint errors in the console.
 
-### `pnpm test`
+### `yarn test`
 
 Launches the test runner in the interactive watch mode.\
 See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
 
-### `pnpm build`
+### `yarn build`
 
 Builds the app for production to the `build` folder.\
 It correctly bundles React in production mode and optimizes the build for the best performance.
@@ -64,7 +64,7 @@ Your app is ready to be deployed!
 
 See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
 
-### `pnpm eject`
+### `yarn eject`
 
 **Note: this is a one-way operation. Once you `eject`, you can’t go back!**
 
@@ -100,6 +100,6 @@ This section has moved here: [https://facebook.github.io/create-react-app/docs/a
 
 This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
 
-### `pnpm build` fails to minify
+### `yarn build` fails to minify
 
 This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)

frontend/__mocks__/createIconsMock.tsx

@@ -1,28 +0,0 @@
-import React from 'react';
-
-const IconMock = React.forwardRef<SVGSVGElement, React.SVGProps<SVGSVGElement>>(
-	(props, ref) => <svg ref={ref} {...props} />,
-);
-IconMock.displayName = 'IconMock';
-
-// Returns a Proxy that resolves any named export to IconMock by default,
-// so `import { AnyIcon } from '@signozhq/icons'` always returns a valid component.
-// Pass `overrides` to swap in test-specific stubs (e.g. icons with data-testid).
-export function createIconsMock(
-	overrides: Record<string, unknown> = {},
-): Record<string | symbol, unknown> {
-	return new Proxy(
-		{ __esModule: true, default: IconMock, ...overrides } as Record<
-			string | symbol,
-			unknown
-		>,
-		{
-			get(target, prop: string | symbol): unknown {
-				if (prop in target) {
-					return target[prop as string];
-				}
-				return IconMock;
-			},
-		},
-	);
-}

frontend/__mocks__/signozhqIconsMock.tsx

@@ -1,3 +0,0 @@
-import { createIconsMock } from './createIconsMock';
-
-module.exports = createIconsMock();

frontend/jest.config.ts

@@ -24,8 +24,8 @@ const config: Config.InitialOptions = {
 		'^.*/useSafeNavigate$': USE_SAFE_NAVIGATE_MOCK_PATH,
 		'^constants/env$': '<rootDir>/__mocks__/env.ts',
 		'^src/constants/env$': '<rootDir>/__mocks__/env.ts',
-		'^@signozhq/icons$': '<rootDir>/__mocks__/signozhqIconsMock.tsx',
-		'^test-mocks/(.*)$': '<rootDir>/__mocks__/$1',
+		'^@signozhq/icons$':
+			'<rootDir>/node_modules/@signozhq/icons/dist/index.esm.js',
 		'^react-syntax-highlighter/dist/esm/(.*)$':
 			'<rootDir>/node_modules/react-syntax-highlighter/dist/cjs/$1',
 		'^@signozhq/(?!ui(?:/|$))([^/]+)$':
@@ -46,11 +46,7 @@ const config: Config.InitialOptions = {
 	},
 	transformIgnorePatterns: [
 		// @chenglou/pretext is ESM-only; @signozhq/ui pulls it in via text-ellipsis.
-		// Pattern 1: allow .pnpm virtual store through (handled by pattern 2), plus root-level ESM packages.
-		'node_modules/(?!(\\.pnpm|lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou/pretext|@signozhq/design-tokens|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid)/)',
-		// Pattern 2: pnpm virtual store — ignore everything except ESM-only packages.
-		// pnpm encodes scoped packages as @scope+name@version, so match on scope prefix.
-		'node_modules/\\.pnpm/(?!(lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou|@signozhq|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs|uuid)[^/]*/node_modules)',
+		'node_modules/(?!(lodash-es|react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend|axios|@chenglou/pretext|@signozhq/design-tokens|@signozhq/table|@signozhq/calendar|@signozhq/input|@signozhq/popover|@signozhq/*|date-fns|d3-interpolate|d3-color|api|@codemirror|@lezer|@marijn|@grafana|nuqs)/)',
 	],
 	setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
 	testPathIgnorePatterns: ['/node_modules/', '/public/'],

frontend/jest.setup.ts

@@ -6,7 +6,6 @@
  * Adds custom matchers from the react testing library to all tests
  */
 import '@testing-library/jest-dom';
-import '@testing-library/jest-dom/extend-expect';
 import 'jest-styled-components';
 
 import { server } from './src/mocks-server/server';

frontend/knip.json

@@ -1,10 +1,5 @@
 {
   "$schema": "https://unpkg.com/knip@5/schema.json",
   "project": ["src/**/*.ts", "src/**/*.tsx"],
-  "ignore": ["src/api/generated/**/*.ts", "src/typings/*.ts"],
-  "ignoreDependencies": [
-    "http-proxy-middleware",
-    "react-error-boundary",
-    "@typescript/native-preview"
-  ]
+  "ignore": ["src/api/generated/**/*.ts", "src/typings/*.ts"]
 }

frontend/orval.config.ts

@@ -80,7 +80,7 @@ export default defineConfig({
 				header: (info: { title: string; version: string }): string[] => [
 					`! Do not edit manually`,
 					`* The file has been auto-generated using Orval for SigNoz`,
-					`* regenerate with 'pnpm generate:api'`,
+					`* regenerate with 'yarn generate:api'`,
 					...(info.title ? [info.title] : []),
 					...(info.version ? [`OpenAPI spec version: ${info.version}`] : []),
 				],

frontend/package.json

@@ -18,7 +18,7 @@
     "jest": "jest",
     "jest:coverage": "jest --coverage",
     "jest:watch": "jest --watch",
-    "postinstall": "pnpm i18n:generate-hash && (is-ci || pnpm husky:configure)  && node scripts/update-registry.cjs",
+    "postinstall": "yarn i18n:generate-hash && (is-ci || yarn husky:configure)  && node scripts/update-registry.cjs",
     "husky:configure": "cd .. && husky install frontend/.husky && cd frontend && chmod ug+x .husky/*",
     "commitlint": "commitlint --edit $1",
     "test": "jest",
@@ -32,20 +32,23 @@
   "license": "ISC",
   "dependencies": {
     "@ant-design/colors": "6.0.0",
+    "@ant-design/icons": "4.8.0",
     "@codemirror/autocomplete": "6.18.6",
     "@codemirror/lang-javascript": "6.2.3",
-    "@codemirror/state": "6.5.2",
-    "@codemirror/view": "6.36.6",
     "@dnd-kit/core": "6.1.0",
     "@dnd-kit/modifiers": "7.0.0",
     "@dnd-kit/sortable": "8.0.0",
     "@dnd-kit/utilities": "3.2.2",
-    "@grafana/data": "^11.6.14",
-    "@monaco-editor/react": "^4.7.0",
+    "@grafana/data": "^11.2.3",
+    "@mdx-js/loader": "2.3.0",
+    "@mdx-js/react": "2.3.0",
+    "@monaco-editor/react": "^4.3.1",
+    "@radix-ui/react-tabs": "1.0.4",
+    "@radix-ui/react-tooltip": "1.0.7",
     "@sentry/react": "8.41.0",
     "@sentry/vite-plugin": "2.22.6",
     "@signozhq/design-tokens": "2.1.4",
-    "@signozhq/icons": "0.4.0",
+    "@signozhq/icons": "0.1.0",
     "@signozhq/resizable": "0.0.2",
     "@signozhq/ui": "0.0.18",
     "@tanstack/react-table": "8.21.3",
@@ -53,6 +56,7 @@
     "@uiw/codemirror-theme-copilot": "4.23.11",
     "@uiw/codemirror-theme-github": "4.24.1",
     "@uiw/react-codemirror": "4.23.10",
+    "@uiw/react-md-editor": "3.23.5",
     "@visx/group": "3.3.0",
     "@visx/hierarchy": "3.12.0",
     "@visx/shape": "3.5.0",
@@ -62,36 +66,46 @@
     "antd": "5.11.0",
     "antd-table-saveas-excel": "2.2.1",
     "antlr4": "4.13.2",
-    "axios": "1.16.0",
+    "axios": "1.12.0",
     "babel-jest": "^29.6.4",
+    "babel-loader": "9.1.3",
+    "babel-plugin-named-asset-import": "^0.3.7",
+    "babel-preset-minify": "^0.5.1",
+    "babel-preset-react-app": "^10.0.1",
     "chart.js": "3.9.1",
     "chartjs-adapter-date-fns": "^2.0.0",
     "chartjs-plugin-annotation": "^1.4.0",
     "classnames": "2.3.2",
     "color": "^4.2.1",
+    "color-alpha": "2.0.0",
+    "cross-env": "^7.0.3",
     "crypto-js": "4.2.0",
     "d3-hierarchy": "3.1.2",
     "dayjs": "^1.10.7",
-    "dompurify": "3.4.0",
+    "dompurify": "3.2.4",
+    "dotenv": "8.2.0",
     "event-source-polyfill": "1.0.31",
     "eventemitter3": "5.0.1",
+    "fontfaceobserver": "2.3.0",
     "history": "4.10.1",
-    "http-proxy-middleware": "4.0.0",
+    "http-proxy-middleware": "3.0.5",
     "http-status-codes": "2.3.0",
     "i18next": "^21.6.12",
     "i18next-browser-languagedetector": "^6.1.3",
-    "i18next-http-backend": "^4.0.0",
+    "i18next-http-backend": "^1.3.2",
     "immer": "11.1.3",
     "jest": "30.2.0",
     "js-base64": "^3.7.2",
     "lodash-es": "^4.17.21",
+    "lucide-react": "0.498.0",
+    "mini-css-extract-plugin": "2.4.5",
     "motion": "12.4.13",
     "nuqs": "2.8.8",
     "overlayscrollbars": "^2.8.1",
     "overlayscrollbars-react": "^0.5.6",
     "papaparse": "5.4.1",
     "posthog-js": "1.298.0",
-    "rc-select": "14.10.0",
+    "rc-tween-one": "3.0.6",
     "react": "18.2.0",
     "react-addons-update": "15.6.3",
     "react-beautiful-dnd": "13.1.1",
@@ -107,12 +121,13 @@
     "react-hook-form": "7.71.2",
     "react-i18next": "^11.16.1",
     "react-json-tree": "^0.20.0",
+    "react-lottie": "1.2.10",
     "react-markdown": "8.0.7",
     "react-query": "3.39.3",
     "react-redux": "^7.2.2",
     "react-rnd": "^10.5.3",
     "react-router-dom": "^5.2.0",
-    "react-router-dom-v5-compat": "6.30.3",
+    "react-router-dom-v5-compat": "6.27.0",
     "react-syntax-highlighter": "15.5.0",
     "react-use": "^17.3.2",
     "react-virtuoso": "4.0.3",
@@ -121,13 +136,16 @@
     "rehype-raw": "7.0.0",
     "rollup-plugin-visualizer": "7.0.0",
     "rrule": "2.8.1",
+    "stream": "^0.0.2",
     "styled-components": "^5.3.11",
     "timestamp-nano": "^1.0.0",
+    "ts-node": "^10.2.1",
     "typescript": "5.9.3",
     "uplot": "1.6.31",
     "uuid": "^8.3.2",
     "vite": "npm:rolldown-vite@7.3.1",
     "vite-plugin-html": "3.2.2",
+    "web-vitals": "^0.2.4",
     "zod": "4.3.6",
     "zustand": "5.0.11"
   },
@@ -146,23 +164,25 @@
   "devDependencies": {
     "@babel/core": "^7.22.11",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-syntax-jsx": "^7.12.13",
     "@babel/preset-env": "^7.22.14",
     "@babel/preset-react": "^7.12.13",
     "@babel/preset-typescript": "^7.21.4",
-    "@commitlint/cli": "20.4.4",
-    "@commitlint/config-conventional": "20.4.4",
-    "@jest/globals": "30.4.1",
+    "@commitlint/cli": "^20.4.2",
+    "@commitlint/config-conventional": "^20.4.2",
+    "@faker-js/faker": "9.3.0",
+    "@jest/globals": "30.2.0",
     "@testing-library/jest-dom": "5.16.5",
     "@testing-library/react": "13.4.0",
     "@testing-library/user-event": "14.4.3",
     "@types/color": "^3.0.3",
     "@types/crypto-js": "4.2.2",
+    "@types/dompurify": "^2.4.0",
     "@types/event-source-polyfill": "^1.0.0",
-    "@types/d3-hierarchy": "1.1.11",
-    "@types/history": "4.7.11",
+    "@types/fontfaceobserver": "2.1.0",
     "@types/jest": "30.0.0",
-    "@jest/types": "30.2.0",
     "@types/lodash-es": "^4.17.4",
+    "@types/mini-css-extract-plugin": "^2.5.1",
     "@types/node": "^16.10.3",
     "@types/papaparse": "5.3.7",
     "@types/react": "18.0.26",
@@ -170,36 +190,48 @@
     "@types/react-beautiful-dnd": "13.1.8",
     "@types/react-dom": "18.0.10",
     "@types/react-grid-layout": "^1.1.2",
+    "@types/react-helmet-async": "1.0.3",
+    "@types/react-lottie": "1.2.10",
     "@types/react-redux": "^7.1.11",
     "@types/react-resizable": "3.0.3",
     "@types/react-router-dom": "^5.1.6",
     "@types/react-syntax-highlighter": "15.5.13",
     "@types/redux-mock-store": "1.0.4",
     "@types/styled-components": "^5.1.4",
-    "@types/testing-library__jest-dom": "^5.14.5",
     "@types/uuid": "^8.3.1",
-    "@typescript/native-preview": "7.0.0-dev.20260430.1",
+    "@typescript/native-preview": "7.0.0-dev.20260421.2",
+    "autoprefixer": "10.4.19",
+    "babel-plugin-styled-components": "^1.12.0",
     "eslint-plugin-sonarjs": "4.0.2",
-    "glob": "^13.0.6",
     "husky": "^7.0.4",
+    "imagemin": "^8.0.1",
+    "imagemin-svgo": "^10.0.1",
     "is-ci": "^3.0.1",
     "jest-environment-jsdom": "29.7.0",
+    "jest-environment-node": "29.7.0",
     "jest-styled-components": "^7.2.0",
-    "lint-staged": "^17.0.4",
+    "lint-staged": "^12.5.0",
     "msw": "1.3.2",
-    "orval": "8.9.1",
+    "npm-run-all": "latest",
+    "orval": "7.18.0",
     "oxfmt": "0.47.0",
     "oxlint": "1.62.0",
     "oxlint-tsgolint": "0.22.1",
-    "postcss": "8.5.14",
+    "portfinder-sync": "^0.0.2",
+    "postcss": "8.5.6",
     "postcss-scss": "4.0.9",
+    "prop-types": "15.8.1",
+    "react-hooks-testing-library": "0.6.0",
     "react-resizable": "3.0.4",
     "redux-mock-store": "1.5.4",
     "sass": "1.97.3",
     "sharp": "0.34.5",
     "stylelint": "17.7.0",
-    "svgo": "4.0.1",
-    "ts-jest": "29.4.9",
+    "stylelint-scss": "7.0.0",
+    "svgo": "4.0.0",
+    "ts-api-utils": "2.4.0",
+    "ts-jest": "29.4.6",
+    "ts-node": "^10.2.1",
     "typescript-plugin-css-modules": "5.2.0",
     "use-sync-external-store": "1.6.0",
     "vite-plugin-checker": "0.12.0",
@@ -227,7 +259,7 @@
     "xml2js": "0.5.0",
     "phin": "^3.7.1",
     "body-parser": "1.20.3",
-    "http-proxy-middleware": "4.0.0",
+    "http-proxy-middleware": "3.0.5",
     "cross-spawn": "7.0.5",
     "cookie": "^0.7.1",
     "serialize-javascript": "6.0.2",

frontend/pnpm-workspace.yaml

@@ -1,6 +0,0 @@
-trustPolicy: no-downgrade
-minimumReleaseAge: 2880 # 2d
-minimumReleaseAgeStrict: true
-minimumReleaseAgeExclude:
- - '@signozhq/*'
-blockExoticSubdeps: true

frontend/scripts/post-types-generation.sh

@@ -16,7 +16,7 @@ echo "\n✅ Tag files renamed to index.ts"
 
 # Format generated files
 echo "\n\n---\nRunning prettier...\n"
-if ! pnpm prettify src/api/generated; then
+if ! yarn prettify src/api/generated; then
   echo "Formatting failed!"
   exit 1
 fi
@@ -25,7 +25,7 @@ echo "\n✅ Formatting successful"
 
 # Fix linting issues
 echo "\n\n---\nRunning lint...\n"
-if ! pnpm lint:generated; then
+if ! yarn lint:generated; then
   echo "Lint check failed! Please fix linting errors before proceeding."
   exit 1
 fi

frontend/src/ReactI18/index.tsx

@@ -21,7 +21,7 @@ i18n
 			escapeValue: false, // not needed for react as it escapes by default
 		},
 		backend: {
-			loadPath: (language: string, namespace: string): string => {
+			loadPath: (language, namespace) => {
 				const ns = namespace[0];
 				const pathkey = `/${language}/${ns}`;
 				const hash = cacheBursting[pathkey as keyof typeof cacheBursting] || '';

frontend/src/api/generated/services/alerts/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useQuery } from 'react-query';
 import type {
@@ -78,7 +77,9 @@ export function useGetAlerts<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/authdomains/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -99,7 +98,9 @@ export function useListAuthDomains<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -122,7 +123,7 @@ export const invalidateListAuthDomains = async (
  * @summary Create auth domain
  */
 export const createAuthDomain = (
-	authtypesPostableAuthDomainDTO?: BodyType<AuthtypesPostableAuthDomainDTO>,
+	authtypesPostableAuthDomainDTO: BodyType<AuthtypesPostableAuthDomainDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateAuthDomain201>({
@@ -141,13 +142,13 @@ export const getCreateAuthDomainMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createAuthDomain>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableAuthDomainDTO> },
+		{ data: BodyType<AuthtypesPostableAuthDomainDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createAuthDomain>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableAuthDomainDTO> },
+	{ data: BodyType<AuthtypesPostableAuthDomainDTO> },
 	TContext
 > => {
 	const mutationKey = ['createAuthDomain'];
@@ -161,7 +162,7 @@ export const getCreateAuthDomainMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createAuthDomain>>,
-		{ data?: BodyType<AuthtypesPostableAuthDomainDTO> }
+		{ data: BodyType<AuthtypesPostableAuthDomainDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -175,8 +176,7 @@ export type CreateAuthDomainMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createAuthDomain>>
 >;
 export type CreateAuthDomainMutationBody =
-	| BodyType<AuthtypesPostableAuthDomainDTO>
-	| undefined;
+	BodyType<AuthtypesPostableAuthDomainDTO>;
 export type CreateAuthDomainMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -189,29 +189,27 @@ export const useCreateAuthDomain = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createAuthDomain>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableAuthDomainDTO> },
+		{ data: BodyType<AuthtypesPostableAuthDomainDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createAuthDomain>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableAuthDomainDTO> },
+	{ data: BodyType<AuthtypesPostableAuthDomainDTO> },
 	TContext
 > => {
-	return useMutation(getCreateAuthDomainMutationOptions(options));
+	const mutationOptions = getCreateAuthDomainMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes an auth domain
  * @summary Delete auth domain
  */
-export const deleteAuthDomain = (
-	{ id }: DeleteAuthDomainPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteAuthDomain = ({ id }: DeleteAuthDomainPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/domains/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -277,7 +275,9 @@ export const useDeleteAuthDomain = <
 	{ pathParams: DeleteAuthDomainPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteAuthDomainMutationOptions(options));
+	const mutationOptions = getDeleteAuthDomainMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns an auth domain by ID
@@ -361,7 +361,9 @@ export function useGetAuthDomain<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -386,15 +388,13 @@ export const invalidateGetAuthDomain = async (
  */
 export const updateAuthDomain = (
 	{ id }: UpdateAuthDomainPathParameters,
-	authtypesUpdatableAuthDomainDTO?: BodyType<AuthtypesUpdatableAuthDomainDTO>,
-	signal?: AbortSignal,
+	authtypesUpdatableAuthDomainDTO: BodyType<AuthtypesUpdatableAuthDomainDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/domains/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: authtypesUpdatableAuthDomainDTO,
-		signal,
 	});
 };
 
@@ -407,7 +407,7 @@ export const getUpdateAuthDomainMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data?: BodyType<AuthtypesUpdatableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		},
 		TContext
 	>;
@@ -416,7 +416,7 @@ export const getUpdateAuthDomainMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateAuthDomainPathParameters;
-		data?: BodyType<AuthtypesUpdatableAuthDomainDTO>;
+		data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 	},
 	TContext
 > => {
@@ -433,7 +433,7 @@ export const getUpdateAuthDomainMutationOptions = <
 		Awaited<ReturnType<typeof updateAuthDomain>>,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data?: BodyType<AuthtypesUpdatableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -448,8 +448,7 @@ export type UpdateAuthDomainMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateAuthDomain>>
 >;
 export type UpdateAuthDomainMutationBody =
-	| BodyType<AuthtypesUpdatableAuthDomainDTO>
-	| undefined;
+	BodyType<AuthtypesUpdatableAuthDomainDTO>;
 export type UpdateAuthDomainMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -464,7 +463,7 @@ export const useUpdateAuthDomain = <
 		TError,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data?: BodyType<AuthtypesUpdatableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		},
 		TContext
 	>;
@@ -473,9 +472,11 @@ export const useUpdateAuthDomain = <
 	TError,
 	{
 		pathParams: UpdateAuthDomainPathParameters;
-		data?: BodyType<AuthtypesUpdatableAuthDomainDTO>;
+		data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateAuthDomainMutationOptions(options));
+	const mutationOptions = getUpdateAuthDomainMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/authz/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation } from 'react-query';
 import type {
@@ -26,7 +25,7 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  * @summary Check permissions
  */
 export const authzCheck = (
-	authtypesTransactionDTO?: BodyType<AuthtypesTransactionDTO[]>,
+	authtypesTransactionDTO: BodyType<AuthtypesTransactionDTO[]>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<AuthzCheck200>({
@@ -45,13 +44,13 @@ export const getAuthzCheckMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof authzCheck>>,
 		TError,
-		{ data?: BodyType<AuthtypesTransactionDTO[]> },
+		{ data: BodyType<AuthtypesTransactionDTO[]> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof authzCheck>>,
 	TError,
-	{ data?: BodyType<AuthtypesTransactionDTO[]> },
+	{ data: BodyType<AuthtypesTransactionDTO[]> },
 	TContext
 > => {
 	const mutationKey = ['authzCheck'];
@@ -65,7 +64,7 @@ export const getAuthzCheckMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof authzCheck>>,
-		{ data?: BodyType<AuthtypesTransactionDTO[]> }
+		{ data: BodyType<AuthtypesTransactionDTO[]> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -78,9 +77,7 @@ export const getAuthzCheckMutationOptions = <
 export type AuthzCheckMutationResult = NonNullable<
 	Awaited<ReturnType<typeof authzCheck>>
 >;
-export type AuthzCheckMutationBody =
-	| BodyType<AuthtypesTransactionDTO[]>
-	| undefined;
+export type AuthzCheckMutationBody = BodyType<AuthtypesTransactionDTO[]>;
 export type AuthzCheckMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -93,14 +90,16 @@ export const useAuthzCheck = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof authzCheck>>,
 		TError,
-		{ data?: BodyType<AuthtypesTransactionDTO[]> },
+		{ data: BodyType<AuthtypesTransactionDTO[]> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof authzCheck>>,
 	TError,
-	{ data?: BodyType<AuthtypesTransactionDTO[]> },
+	{ data: BodyType<AuthtypesTransactionDTO[]> },
 	TContext
 > => {
-	return useMutation(getAuthzCheckMutationOptions(options));
+	const mutationOptions = getAuthzCheckMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/channels/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -99,7 +98,9 @@ export function useListChannels<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -122,7 +123,7 @@ export const invalidateListChannels = async (
  * @summary Create notification channel
  */
 export const createChannel = (
-	alertmanagertypesPostableChannelDTO?: BodyType<AlertmanagertypesPostableChannelDTO>,
+	alertmanagertypesPostableChannelDTO: BodyType<AlertmanagertypesPostableChannelDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateChannel201>({
@@ -141,13 +142,13 @@ export const getCreateChannelMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createChannel>>,
 		TError,
-		{ data?: BodyType<AlertmanagertypesPostableChannelDTO> },
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createChannel>>,
 	TError,
-	{ data?: BodyType<AlertmanagertypesPostableChannelDTO> },
+	{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 	TContext
 > => {
 	const mutationKey = ['createChannel'];
@@ -161,7 +162,7 @@ export const getCreateChannelMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createChannel>>,
-		{ data?: BodyType<AlertmanagertypesPostableChannelDTO> }
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -175,8 +176,7 @@ export type CreateChannelMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createChannel>>
 >;
 export type CreateChannelMutationBody =
-	| BodyType<AlertmanagertypesPostableChannelDTO>
-	| undefined;
+	BodyType<AlertmanagertypesPostableChannelDTO>;
 export type CreateChannelMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -189,29 +189,27 @@ export const useCreateChannel = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createChannel>>,
 		TError,
-		{ data?: BodyType<AlertmanagertypesPostableChannelDTO> },
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createChannel>>,
 	TError,
-	{ data?: BodyType<AlertmanagertypesPostableChannelDTO> },
+	{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 	TContext
 > => {
-	return useMutation(getCreateChannelMutationOptions(options));
+	const mutationOptions = getCreateChannelMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes a notification channel by ID
  * @summary Delete notification channel
  */
-export const deleteChannelByID = (
-	{ id }: DeleteChannelByIDPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteChannelByID = ({ id }: DeleteChannelByIDPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/channels/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -277,7 +275,9 @@ export const useDeleteChannelByID = <
 	{ pathParams: DeleteChannelByIDPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteChannelByIDMutationOptions(options));
+	const mutationOptions = getDeleteChannelByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns a notification channel by ID
@@ -361,7 +361,9 @@ export function useGetChannelByID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -386,15 +388,13 @@ export const invalidateGetChannelByID = async (
  */
 export const updateChannelByID = (
 	{ id }: UpdateChannelByIDPathParameters,
-	configReceiverDTO?: BodyType<ConfigReceiverDTO>,
-	signal?: AbortSignal,
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/channels/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: configReceiverDTO,
-		signal,
 	});
 };
 
@@ -407,7 +407,7 @@ export const getUpdateChannelByIDMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateChannelByIDPathParameters;
-			data?: BodyType<ConfigReceiverDTO>;
+			data: BodyType<ConfigReceiverDTO>;
 		},
 		TContext
 	>;
@@ -416,7 +416,7 @@ export const getUpdateChannelByIDMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateChannelByIDPathParameters;
-		data?: BodyType<ConfigReceiverDTO>;
+		data: BodyType<ConfigReceiverDTO>;
 	},
 	TContext
 > => {
@@ -433,7 +433,7 @@ export const getUpdateChannelByIDMutationOptions = <
 		Awaited<ReturnType<typeof updateChannelByID>>,
 		{
 			pathParams: UpdateChannelByIDPathParameters;
-			data?: BodyType<ConfigReceiverDTO>;
+			data: BodyType<ConfigReceiverDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -447,9 +447,7 @@ export const getUpdateChannelByIDMutationOptions = <
 export type UpdateChannelByIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateChannelByID>>
 >;
-export type UpdateChannelByIDMutationBody =
-	| BodyType<ConfigReceiverDTO>
-	| undefined;
+export type UpdateChannelByIDMutationBody = BodyType<ConfigReceiverDTO>;
 export type UpdateChannelByIDMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -464,7 +462,7 @@ export const useUpdateChannelByID = <
 		TError,
 		{
 			pathParams: UpdateChannelByIDPathParameters;
-			data?: BodyType<ConfigReceiverDTO>;
+			data: BodyType<ConfigReceiverDTO>;
 		},
 		TContext
 	>;
@@ -473,18 +471,20 @@ export const useUpdateChannelByID = <
 	TError,
 	{
 		pathParams: UpdateChannelByIDPathParameters;
-		data?: BodyType<ConfigReceiverDTO>;
+		data: BodyType<ConfigReceiverDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateChannelByIDMutationOptions(options));
+	const mutationOptions = getUpdateChannelByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint tests a notification channel by sending a test notification
  * @summary Test notification channel
  */
 export const testChannel = (
-	configReceiverDTO?: BodyType<ConfigReceiverDTO>,
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -503,13 +503,13 @@ export const getTestChannelMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testChannel>>,
 		TError,
-		{ data?: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<ConfigReceiverDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof testChannel>>,
 	TError,
-	{ data?: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<ConfigReceiverDTO> },
 	TContext
 > => {
 	const mutationKey = ['testChannel'];
@@ -523,7 +523,7 @@ export const getTestChannelMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof testChannel>>,
-		{ data?: BodyType<ConfigReceiverDTO> }
+		{ data: BodyType<ConfigReceiverDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -536,7 +536,7 @@ export const getTestChannelMutationOptions = <
 export type TestChannelMutationResult = NonNullable<
 	Awaited<ReturnType<typeof testChannel>>
 >;
-export type TestChannelMutationBody = BodyType<ConfigReceiverDTO> | undefined;
+export type TestChannelMutationBody = BodyType<ConfigReceiverDTO>;
 export type TestChannelMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -549,16 +549,18 @@ export const useTestChannel = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testChannel>>,
 		TError,
-		{ data?: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<ConfigReceiverDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof testChannel>>,
 	TError,
-	{ data?: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<ConfigReceiverDTO> },
 	TContext
 > => {
-	return useMutation(getTestChannelMutationOptions(options));
+	const mutationOptions = getTestChannelMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Deprecated: use /api/v1/channels/test instead
@@ -566,7 +568,7 @@ export const useTestChannel = <
  * @summary Test notification channel (deprecated)
  */
 export const testChannelDeprecated = (
-	configReceiverDTO?: BodyType<ConfigReceiverDTO>,
+	configReceiverDTO: BodyType<ConfigReceiverDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -585,13 +587,13 @@ export const getTestChannelDeprecatedMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testChannelDeprecated>>,
 		TError,
-		{ data?: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<ConfigReceiverDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof testChannelDeprecated>>,
 	TError,
-	{ data?: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<ConfigReceiverDTO> },
 	TContext
 > => {
 	const mutationKey = ['testChannelDeprecated'];
@@ -605,7 +607,7 @@ export const getTestChannelDeprecatedMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof testChannelDeprecated>>,
-		{ data?: BodyType<ConfigReceiverDTO> }
+		{ data: BodyType<ConfigReceiverDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -618,9 +620,7 @@ export const getTestChannelDeprecatedMutationOptions = <
 export type TestChannelDeprecatedMutationResult = NonNullable<
 	Awaited<ReturnType<typeof testChannelDeprecated>>
 >;
-export type TestChannelDeprecatedMutationBody =
-	| BodyType<ConfigReceiverDTO>
-	| undefined;
+export type TestChannelDeprecatedMutationBody = BodyType<ConfigReceiverDTO>;
 export type TestChannelDeprecatedMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -635,14 +635,16 @@ export const useTestChannelDeprecated = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testChannelDeprecated>>,
 		TError,
-		{ data?: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<ConfigReceiverDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof testChannelDeprecated>>,
 	TError,
-	{ data?: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<ConfigReceiverDTO> },
 	TContext
 > => {
-	return useMutation(getTestChannelDeprecatedMutationOptions(options));
+	const mutationOptions = getTestChannelDeprecatedMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/cloudintegration/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -57,7 +56,7 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  */
 export const agentCheckInDeprecated = (
 	{ cloudProvider }: AgentCheckInDeprecatedPathParameters,
-	cloudintegrationtypesPostableAgentCheckInDTO?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>,
+	cloudintegrationtypesPostableAgentCheckInDTO: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<AgentCheckInDeprecated200>({
@@ -78,7 +77,7 @@ export const getAgentCheckInDeprecatedMutationOptions = <
 		TError,
 		{
 			pathParams: AgentCheckInDeprecatedPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		},
 		TContext
 	>;
@@ -87,7 +86,7 @@ export const getAgentCheckInDeprecatedMutationOptions = <
 	TError,
 	{
 		pathParams: AgentCheckInDeprecatedPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+		data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 	},
 	TContext
 > => {
@@ -104,7 +103,7 @@ export const getAgentCheckInDeprecatedMutationOptions = <
 		Awaited<ReturnType<typeof agentCheckInDeprecated>>,
 		{
 			pathParams: AgentCheckInDeprecatedPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -119,8 +118,7 @@ export type AgentCheckInDeprecatedMutationResult = NonNullable<
 	Awaited<ReturnType<typeof agentCheckInDeprecated>>
 >;
 export type AgentCheckInDeprecatedMutationBody =
-	| BodyType<CloudintegrationtypesPostableAgentCheckInDTO>
-	| undefined;
+	BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 export type AgentCheckInDeprecatedMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -137,7 +135,7 @@ export const useAgentCheckInDeprecated = <
 		TError,
 		{
 			pathParams: AgentCheckInDeprecatedPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		},
 		TContext
 	>;
@@ -146,11 +144,13 @@ export const useAgentCheckInDeprecated = <
 	TError,
 	{
 		pathParams: AgentCheckInDeprecatedPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+		data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getAgentCheckInDeprecatedMutationOptions(options));
+	const mutationOptions = getAgentCheckInDeprecatedMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint lists the accounts for the specified cloud provider
@@ -235,7 +235,9 @@ export function useListAccounts<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -260,7 +262,7 @@ export const invalidateListAccounts = async (
  */
 export const createAccount = (
 	{ cloudProvider }: CreateAccountPathParameters,
-	cloudintegrationtypesPostableAccountDTO?: BodyType<CloudintegrationtypesPostableAccountDTO>,
+	cloudintegrationtypesPostableAccountDTO: BodyType<CloudintegrationtypesPostableAccountDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateAccount201>({
@@ -281,7 +283,7 @@ export const getCreateAccountMutationOptions = <
 		TError,
 		{
 			pathParams: CreateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAccountDTO>;
+			data: BodyType<CloudintegrationtypesPostableAccountDTO>;
 		},
 		TContext
 	>;
@@ -290,7 +292,7 @@ export const getCreateAccountMutationOptions = <
 	TError,
 	{
 		pathParams: CreateAccountPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAccountDTO>;
+		data: BodyType<CloudintegrationtypesPostableAccountDTO>;
 	},
 	TContext
 > => {
@@ -307,7 +309,7 @@ export const getCreateAccountMutationOptions = <
 		Awaited<ReturnType<typeof createAccount>>,
 		{
 			pathParams: CreateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAccountDTO>;
+			data: BodyType<CloudintegrationtypesPostableAccountDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -322,8 +324,7 @@ export type CreateAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createAccount>>
 >;
 export type CreateAccountMutationBody =
-	| BodyType<CloudintegrationtypesPostableAccountDTO>
-	| undefined;
+	BodyType<CloudintegrationtypesPostableAccountDTO>;
 export type CreateAccountMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -338,7 +339,7 @@ export const useCreateAccount = <
 		TError,
 		{
 			pathParams: CreateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAccountDTO>;
+			data: BodyType<CloudintegrationtypesPostableAccountDTO>;
 		},
 		TContext
 	>;
@@ -347,24 +348,25 @@ export const useCreateAccount = <
 	TError,
 	{
 		pathParams: CreateAccountPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAccountDTO>;
+		data: BodyType<CloudintegrationtypesPostableAccountDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreateAccountMutationOptions(options));
+	const mutationOptions = getCreateAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint disconnects an account for the specified cloud provider
  * @summary Disconnect account
  */
-export const disconnectAccount = (
-	{ cloudProvider, id }: DisconnectAccountPathParameters,
-	signal?: AbortSignal,
-) => {
+export const disconnectAccount = ({
+	cloudProvider,
+	id,
+}: DisconnectAccountPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/accounts/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -430,7 +432,9 @@ export const useDisconnectAccount = <
 	{ pathParams: DisconnectAccountPathParameters },
 	TContext
 > => {
-	return useMutation(getDisconnectAccountMutationOptions(options));
+	const mutationOptions = getDisconnectAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint gets an account for the specified cloud provider
@@ -514,7 +518,9 @@ export function useGetAccount<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -539,15 +545,13 @@ export const invalidateGetAccount = async (
  */
 export const updateAccount = (
 	{ cloudProvider, id }: UpdateAccountPathParameters,
-	cloudintegrationtypesUpdatableAccountDTO?: BodyType<CloudintegrationtypesUpdatableAccountDTO>,
-	signal?: AbortSignal,
+	cloudintegrationtypesUpdatableAccountDTO: BodyType<CloudintegrationtypesUpdatableAccountDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/accounts/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: cloudintegrationtypesUpdatableAccountDTO,
-		signal,
 	});
 };
 
@@ -560,7 +564,7 @@ export const getUpdateAccountMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 		},
 		TContext
 	>;
@@ -569,7 +573,7 @@ export const getUpdateAccountMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateAccountPathParameters;
-		data?: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
+		data: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 	},
 	TContext
 > => {
@@ -586,7 +590,7 @@ export const getUpdateAccountMutationOptions = <
 		Awaited<ReturnType<typeof updateAccount>>,
 		{
 			pathParams: UpdateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -601,8 +605,7 @@ export type UpdateAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateAccount>>
 >;
 export type UpdateAccountMutationBody =
-	| BodyType<CloudintegrationtypesUpdatableAccountDTO>
-	| undefined;
+	BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 export type UpdateAccountMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -617,7 +620,7 @@ export const useUpdateAccount = <
 		TError,
 		{
 			pathParams: UpdateAccountPathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 		},
 		TContext
 	>;
@@ -626,11 +629,13 @@ export const useUpdateAccount = <
 	TError,
 	{
 		pathParams: UpdateAccountPathParameters;
-		data?: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
+		data: BodyType<CloudintegrationtypesUpdatableAccountDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateAccountMutationOptions(options));
+	const mutationOptions = getUpdateAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates a service for the specified cloud provider
@@ -638,15 +643,13 @@ export const useUpdateAccount = <
  */
 export const updateService = (
 	{ cloudProvider, id, serviceId }: UpdateServicePathParameters,
-	cloudintegrationtypesUpdatableServiceDTO?: BodyType<CloudintegrationtypesUpdatableServiceDTO>,
-	signal?: AbortSignal,
+	cloudintegrationtypesUpdatableServiceDTO: BodyType<CloudintegrationtypesUpdatableServiceDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/cloud_integrations/${cloudProvider}/accounts/${id}/services/${serviceId}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: cloudintegrationtypesUpdatableServiceDTO,
-		signal,
 	});
 };
 
@@ -659,7 +662,7 @@ export const getUpdateServiceMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateServicePathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 		},
 		TContext
 	>;
@@ -668,7 +671,7 @@ export const getUpdateServiceMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateServicePathParameters;
-		data?: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 	},
 	TContext
 > => {
@@ -685,7 +688,7 @@ export const getUpdateServiceMutationOptions = <
 		Awaited<ReturnType<typeof updateService>>,
 		{
 			pathParams: UpdateServicePathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -700,8 +703,7 @@ export type UpdateServiceMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateService>>
 >;
 export type UpdateServiceMutationBody =
-	| BodyType<CloudintegrationtypesUpdatableServiceDTO>
-	| undefined;
+	BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 export type UpdateServiceMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -716,7 +718,7 @@ export const useUpdateService = <
 		TError,
 		{
 			pathParams: UpdateServicePathParameters;
-			data?: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+			data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 		},
 		TContext
 	>;
@@ -725,11 +727,13 @@ export const useUpdateService = <
 	TError,
 	{
 		pathParams: UpdateServicePathParameters;
-		data?: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
+		data: BodyType<CloudintegrationtypesUpdatableServiceDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateServiceMutationOptions(options));
+	const mutationOptions = getUpdateServiceMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint is called by the deployed agent to check in
@@ -737,7 +741,7 @@ export const useUpdateService = <
  */
 export const agentCheckIn = (
 	{ cloudProvider }: AgentCheckInPathParameters,
-	cloudintegrationtypesPostableAgentCheckInDTO?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>,
+	cloudintegrationtypesPostableAgentCheckInDTO: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<AgentCheckIn200>({
@@ -758,7 +762,7 @@ export const getAgentCheckInMutationOptions = <
 		TError,
 		{
 			pathParams: AgentCheckInPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		},
 		TContext
 	>;
@@ -767,7 +771,7 @@ export const getAgentCheckInMutationOptions = <
 	TError,
 	{
 		pathParams: AgentCheckInPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+		data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 	},
 	TContext
 > => {
@@ -784,7 +788,7 @@ export const getAgentCheckInMutationOptions = <
 		Awaited<ReturnType<typeof agentCheckIn>>,
 		{
 			pathParams: AgentCheckInPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -799,8 +803,7 @@ export type AgentCheckInMutationResult = NonNullable<
 	Awaited<ReturnType<typeof agentCheckIn>>
 >;
 export type AgentCheckInMutationBody =
-	| BodyType<CloudintegrationtypesPostableAgentCheckInDTO>
-	| undefined;
+	BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 export type AgentCheckInMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -815,7 +818,7 @@ export const useAgentCheckIn = <
 		TError,
 		{
 			pathParams: AgentCheckInPathParameters;
-			data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+			data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 		},
 		TContext
 	>;
@@ -824,11 +827,13 @@ export const useAgentCheckIn = <
 	TError,
 	{
 		pathParams: AgentCheckInPathParameters;
-		data?: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
+		data: BodyType<CloudintegrationtypesPostableAgentCheckInDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getAgentCheckInMutationOptions(options));
+	const mutationOptions = getAgentCheckInMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint retrieves the connection credentials required for integration
@@ -918,7 +923,9 @@ export function useGetConnectionCredentials<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1033,7 +1040,9 @@ export function useListServicesMetadata<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1147,7 +1156,9 @@ export function useGetService<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/dashboard/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -19,19 +18,34 @@ import type {
 } from 'react-query';
 
 import type {
+	CreateDashboardV2201,
 	CreatePublicDashboard201,
 	CreatePublicDashboardPathParameters,
+	CreatePublicDashboardV2200,
+	CreatePublicDashboardV2PathParameters,
+	DashboardtypesJSONPatchDocumentDTO,
+	DashboardtypesPostableDashboardV2DTO,
 	DashboardtypesPostablePublicDashboardDTO,
 	DashboardtypesUpdatablePublicDashboardDTO,
 	DeletePublicDashboardPathParameters,
+	GetDashboardV2200,
+	GetDashboardV2PathParameters,
 	GetPublicDashboard200,
 	GetPublicDashboardData200,
 	GetPublicDashboardDataPathParameters,
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
+	LockDashboardV2PathParameters,
+	PatchDashboardV2200,
+	PatchDashboardV2PathParameters,
 	RenderErrorResponseDTO,
+	UnlockDashboardV2PathParameters,
+	UpdateDashboardV2200,
+	UpdateDashboardV2PathParameters,
 	UpdatePublicDashboardPathParameters,
+	UpdatePublicDashboardV2200,
+	UpdatePublicDashboardV2PathParameters,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
@@ -41,14 +55,12 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  * This endpoint deletes the public sharing config and disables the public sharing of a dashboard
  * @summary Delete public dashboard
  */
-export const deletePublicDashboard = (
-	{ id }: DeletePublicDashboardPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deletePublicDashboard = ({
+	id,
+}: DeletePublicDashboardPathParameters) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -115,7 +127,9 @@ export const useDeletePublicDashboard = <
 	{ pathParams: DeletePublicDashboardPathParameters },
 	TContext
 > => {
-	return useMutation(getDeletePublicDashboardMutationOptions(options));
+	const mutationOptions = getDeletePublicDashboardMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns public sharing config for a dashboard
@@ -200,7 +214,9 @@ export function useGetPublicDashboard<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -225,7 +241,7 @@ export const invalidateGetPublicDashboard = async (
  */
 export const createPublicDashboard = (
 	{ id }: CreatePublicDashboardPathParameters,
-	dashboardtypesPostablePublicDashboardDTO?: BodyType<DashboardtypesPostablePublicDashboardDTO>,
+	dashboardtypesPostablePublicDashboardDTO: BodyType<DashboardtypesPostablePublicDashboardDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreatePublicDashboard201>({
@@ -246,7 +262,7 @@ export const getCreatePublicDashboardMutationOptions = <
 		TError,
 		{
 			pathParams: CreatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
 		},
 		TContext
 	>;
@@ -255,7 +271,7 @@ export const getCreatePublicDashboardMutationOptions = <
 	TError,
 	{
 		pathParams: CreatePublicDashboardPathParameters;
-		data?: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+		data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
 	},
 	TContext
 > => {
@@ -272,7 +288,7 @@ export const getCreatePublicDashboardMutationOptions = <
 		Awaited<ReturnType<typeof createPublicDashboard>>,
 		{
 			pathParams: CreatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -287,8 +303,7 @@ export type CreatePublicDashboardMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createPublicDashboard>>
 >;
 export type CreatePublicDashboardMutationBody =
-	| BodyType<DashboardtypesPostablePublicDashboardDTO>
-	| undefined;
+	BodyType<DashboardtypesPostablePublicDashboardDTO>;
 export type CreatePublicDashboardMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -304,7 +319,7 @@ export const useCreatePublicDashboard = <
 		TError,
 		{
 			pathParams: CreatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
 		},
 		TContext
 	>;
@@ -313,11 +328,13 @@ export const useCreatePublicDashboard = <
 	TError,
 	{
 		pathParams: CreatePublicDashboardPathParameters;
-		data?: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+		data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreatePublicDashboardMutationOptions(options));
+	const mutationOptions = getCreatePublicDashboardMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates the public sharing config for a dashboard
@@ -325,15 +342,13 @@ export const useCreatePublicDashboard = <
  */
 export const updatePublicDashboard = (
 	{ id }: UpdatePublicDashboardPathParameters,
-	dashboardtypesUpdatablePublicDashboardDTO?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>,
-	signal?: AbortSignal,
+	dashboardtypesUpdatablePublicDashboardDTO: BodyType<DashboardtypesUpdatablePublicDashboardDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: dashboardtypesUpdatablePublicDashboardDTO,
-		signal,
 	});
 };
 
@@ -346,7 +361,7 @@ export const getUpdatePublicDashboardMutationOptions = <
 		TError,
 		{
 			pathParams: UpdatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 		},
 		TContext
 	>;
@@ -355,7 +370,7 @@ export const getUpdatePublicDashboardMutationOptions = <
 	TError,
 	{
 		pathParams: UpdatePublicDashboardPathParameters;
-		data?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+		data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 	},
 	TContext
 > => {
@@ -372,7 +387,7 @@ export const getUpdatePublicDashboardMutationOptions = <
 		Awaited<ReturnType<typeof updatePublicDashboard>>,
 		{
 			pathParams: UpdatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -387,8 +402,7 @@ export type UpdatePublicDashboardMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updatePublicDashboard>>
 >;
 export type UpdatePublicDashboardMutationBody =
-	| BodyType<DashboardtypesUpdatablePublicDashboardDTO>
-	| undefined;
+	BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 export type UpdatePublicDashboardMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -404,7 +418,7 @@ export const useUpdatePublicDashboard = <
 		TError,
 		{
 			pathParams: UpdatePublicDashboardPathParameters;
-			data?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 		},
 		TContext
 	>;
@@ -413,11 +427,13 @@ export const useUpdatePublicDashboard = <
 	TError,
 	{
 		pathParams: UpdatePublicDashboardPathParameters;
-		data?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+		data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdatePublicDashboardMutationOptions(options));
+	const mutationOptions = getUpdatePublicDashboardMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the sanitized dashboard data for public access
@@ -503,7 +519,9 @@ export function useGetPublicDashboardData<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -611,7 +629,9 @@ export function useGetPublicDashboardWidgetQueryRange<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -629,3 +649,739 @@ export const invalidateGetPublicDashboardWidgetQueryRange = async (
 
 	return queryClient;
 };
+
+/**
+ * This endpoint creates a v2-shape dashboard with structured metadata, a typed data tree, and resolved tags.
+ * @summary Create dashboard (v2)
+ */
+export const createDashboardV2 = (
+	dashboardtypesPostableDashboardV2DTO: BodyType<DashboardtypesPostableDashboardV2DTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateDashboardV2201>({
+		url: `/api/v2/dashboards`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: dashboardtypesPostableDashboardV2DTO,
+		signal,
+	});
+};
+
+export const getCreateDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createDashboardV2>>,
+		TError,
+		{ data: BodyType<DashboardtypesPostableDashboardV2DTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createDashboardV2>>,
+	TError,
+	{ data: BodyType<DashboardtypesPostableDashboardV2DTO> },
+	TContext
+> => {
+	const mutationKey = ['createDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof createDashboardV2>>,
+		{ data: BodyType<DashboardtypesPostableDashboardV2DTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createDashboardV2(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof createDashboardV2>>
+>;
+export type CreateDashboardV2MutationBody =
+	BodyType<DashboardtypesPostableDashboardV2DTO>;
+export type CreateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create dashboard (v2)
+ */
+export const useCreateDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createDashboardV2>>,
+		TError,
+		{ data: BodyType<DashboardtypesPostableDashboardV2DTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createDashboardV2>>,
+	TError,
+	{ data: BodyType<DashboardtypesPostableDashboardV2DTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint returns a v2-shape dashboard with its tags and public sharing config (if any).
+ * @summary Get dashboard (v2)
+ */
+export const getDashboardV2 = (
+	{ id }: GetDashboardV2PathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetDashboardV2200>({
+		url: `/api/v2/dashboards/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetDashboardV2QueryKey = ({
+	id,
+}: GetDashboardV2PathParameters) => {
+	return [`/api/v2/dashboards/${id}`] as const;
+};
+
+export const getGetDashboardV2QueryOptions = <
+	TData = Awaited<ReturnType<typeof getDashboardV2>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ id }: GetDashboardV2PathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getDashboardV2>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetDashboardV2QueryKey({ id });
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getDashboardV2>>> = ({
+		signal,
+	}) => getDashboardV2({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getDashboardV2>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetDashboardV2QueryResult = NonNullable<
+	Awaited<ReturnType<typeof getDashboardV2>>
+>;
+export type GetDashboardV2QueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get dashboard (v2)
+ */
+
+export function useGetDashboardV2<
+	TData = Awaited<ReturnType<typeof getDashboardV2>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ id }: GetDashboardV2PathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getDashboardV2>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetDashboardV2QueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get dashboard (v2)
+ */
+export const invalidateGetDashboardV2 = async (
+	queryClient: QueryClient,
+	{ id }: GetDashboardV2PathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetDashboardV2QueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * This endpoint applies an RFC 6902 JSON Patch to a v2-shape dashboard. The patch is applied against the postable view of the dashboard (metadata, data, tags), so individual panels, queries, variables, layouts, or tags can be updated without re-sending the rest of the dashboard. Locked dashboards are rejected.
+ * @summary Patch dashboard (v2)
+ */
+export const patchDashboardV2 = (
+	{ id }: PatchDashboardV2PathParameters,
+	dashboardtypesJSONPatchDocumentDTO: BodyType<DashboardtypesJSONPatchDocumentDTO>,
+) => {
+	return GeneratedAPIInstance<PatchDashboardV2200>({
+		url: `/api/v2/dashboards/${id}`,
+		method: 'PATCH',
+		headers: { 'Content-Type': 'application/json' },
+		data: dashboardtypesJSONPatchDocumentDTO,
+	});
+};
+
+export const getPatchDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof patchDashboardV2>>,
+		TError,
+		{
+			pathParams: PatchDashboardV2PathParameters;
+			data: BodyType<DashboardtypesJSONPatchDocumentDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof patchDashboardV2>>,
+	TError,
+	{
+		pathParams: PatchDashboardV2PathParameters;
+		data: BodyType<DashboardtypesJSONPatchDocumentDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['patchDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof patchDashboardV2>>,
+		{
+			pathParams: PatchDashboardV2PathParameters;
+			data: BodyType<DashboardtypesJSONPatchDocumentDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return patchDashboardV2(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type PatchDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof patchDashboardV2>>
+>;
+export type PatchDashboardV2MutationBody =
+	BodyType<DashboardtypesJSONPatchDocumentDTO>;
+export type PatchDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Patch dashboard (v2)
+ */
+export const usePatchDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof patchDashboardV2>>,
+		TError,
+		{
+			pathParams: PatchDashboardV2PathParameters;
+			data: BodyType<DashboardtypesJSONPatchDocumentDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof patchDashboardV2>>,
+	TError,
+	{
+		pathParams: PatchDashboardV2PathParameters;
+		data: BodyType<DashboardtypesJSONPatchDocumentDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getPatchDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint updates a v2-shape dashboard's metadata, data, and tag set. Locked dashboards are rejected.
+ * @summary Update dashboard (v2)
+ */
+export const updateDashboardV2 = (
+	{ id }: UpdateDashboardV2PathParameters,
+	dashboardtypesPostableDashboardV2DTO: BodyType<DashboardtypesPostableDashboardV2DTO>,
+) => {
+	return GeneratedAPIInstance<UpdateDashboardV2200>({
+		url: `/api/v2/dashboards/${id}`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: dashboardtypesPostableDashboardV2DTO,
+	});
+};
+
+export const getUpdateDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateDashboardV2>>,
+		TError,
+		{
+			pathParams: UpdateDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostableDashboardV2DTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateDashboardV2>>,
+	TError,
+	{
+		pathParams: UpdateDashboardV2PathParameters;
+		data: BodyType<DashboardtypesPostableDashboardV2DTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof updateDashboardV2>>,
+		{
+			pathParams: UpdateDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostableDashboardV2DTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateDashboardV2(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateDashboardV2>>
+>;
+export type UpdateDashboardV2MutationBody =
+	BodyType<DashboardtypesPostableDashboardV2DTO>;
+export type UpdateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update dashboard (v2)
+ */
+export const useUpdateDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateDashboardV2>>,
+		TError,
+		{
+			pathParams: UpdateDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostableDashboardV2DTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateDashboardV2>>,
+	TError,
+	{
+		pathParams: UpdateDashboardV2PathParameters;
+		data: BodyType<DashboardtypesPostableDashboardV2DTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
+ * @summary Unlock dashboard (v2)
+ */
+export const unlockDashboardV2 = ({ id }: UnlockDashboardV2PathParameters) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v2/dashboards/${id}/lock`,
+		method: 'DELETE',
+	});
+};
+
+export const getUnlockDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof unlockDashboardV2>>,
+		TError,
+		{ pathParams: UnlockDashboardV2PathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof unlockDashboardV2>>,
+	TError,
+	{ pathParams: UnlockDashboardV2PathParameters },
+	TContext
+> => {
+	const mutationKey = ['unlockDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof unlockDashboardV2>>,
+		{ pathParams: UnlockDashboardV2PathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return unlockDashboardV2(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UnlockDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof unlockDashboardV2>>
+>;
+
+export type UnlockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Unlock dashboard (v2)
+ */
+export const useUnlockDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof unlockDashboardV2>>,
+		TError,
+		{ pathParams: UnlockDashboardV2PathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof unlockDashboardV2>>,
+	TError,
+	{ pathParams: UnlockDashboardV2PathParameters },
+	TContext
+> => {
+	const mutationOptions = getUnlockDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint locks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
+ * @summary Lock dashboard (v2)
+ */
+export const lockDashboardV2 = ({ id }: LockDashboardV2PathParameters) => {
+	return GeneratedAPIInstance<string>({
+		url: `/api/v2/dashboards/${id}/lock`,
+		method: 'PUT',
+	});
+};
+
+export const getLockDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof lockDashboardV2>>,
+		TError,
+		{ pathParams: LockDashboardV2PathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof lockDashboardV2>>,
+	TError,
+	{ pathParams: LockDashboardV2PathParameters },
+	TContext
+> => {
+	const mutationKey = ['lockDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof lockDashboardV2>>,
+		{ pathParams: LockDashboardV2PathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return lockDashboardV2(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type LockDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof lockDashboardV2>>
+>;
+
+export type LockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Lock dashboard (v2)
+ */
+export const useLockDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof lockDashboardV2>>,
+		TError,
+		{ pathParams: LockDashboardV2PathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof lockDashboardV2>>,
+	TError,
+	{ pathParams: LockDashboardV2PathParameters },
+	TContext
+> => {
+	const mutationOptions = getLockDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint creates the public sharing config for a v2 dashboard and returns the dashboard with the new public config attached. Lock state does not gate this endpoint.
+ * @summary Make a dashboard v2 public
+ */
+export const createPublicDashboardV2 = (
+	{ id }: CreatePublicDashboardV2PathParameters,
+	dashboardtypesPostablePublicDashboardDTO: BodyType<DashboardtypesPostablePublicDashboardDTO>,
+) => {
+	return GeneratedAPIInstance<CreatePublicDashboardV2200>({
+		url: `/api/v2/dashboards/${id}/public`,
+		method: 'PATCH',
+		headers: { 'Content-Type': 'application/json' },
+		data: dashboardtypesPostablePublicDashboardDTO,
+	});
+};
+
+export const getCreatePublicDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createPublicDashboardV2>>,
+		TError,
+		{
+			pathParams: CreatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createPublicDashboardV2>>,
+	TError,
+	{
+		pathParams: CreatePublicDashboardV2PathParameters;
+		data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['createPublicDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof createPublicDashboardV2>>,
+		{
+			pathParams: CreatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return createPublicDashboardV2(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreatePublicDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof createPublicDashboardV2>>
+>;
+export type CreatePublicDashboardV2MutationBody =
+	BodyType<DashboardtypesPostablePublicDashboardDTO>;
+export type CreatePublicDashboardV2MutationError =
+	ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Make a dashboard v2 public
+ */
+export const useCreatePublicDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createPublicDashboardV2>>,
+		TError,
+		{
+			pathParams: CreatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createPublicDashboardV2>>,
+	TError,
+	{
+		pathParams: CreatePublicDashboardV2PathParameters;
+		data: BodyType<DashboardtypesPostablePublicDashboardDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getCreatePublicDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * This endpoint updates the public sharing config (time range settings) of an already-public v2 dashboard. Lock state does not gate this endpoint.
+ * @summary Update public sharing config for a dashboard v2
+ */
+export const updatePublicDashboardV2 = (
+	{ id }: UpdatePublicDashboardV2PathParameters,
+	dashboardtypesUpdatablePublicDashboardDTO: BodyType<DashboardtypesUpdatablePublicDashboardDTO>,
+) => {
+	return GeneratedAPIInstance<UpdatePublicDashboardV2200>({
+		url: `/api/v2/dashboards/${id}/public`,
+		method: 'PUT',
+		headers: { 'Content-Type': 'application/json' },
+		data: dashboardtypesUpdatablePublicDashboardDTO,
+	});
+};
+
+export const getUpdatePublicDashboardV2MutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updatePublicDashboardV2>>,
+		TError,
+		{
+			pathParams: UpdatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updatePublicDashboardV2>>,
+	TError,
+	{
+		pathParams: UpdatePublicDashboardV2PathParameters;
+		data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updatePublicDashboardV2'];
+	const { mutation: mutationOptions } = options
+		? options.mutation &&
+			'mutationKey' in options.mutation &&
+			options.mutation.mutationKey
+			? options
+			: { ...options, mutation: { ...options.mutation, mutationKey } }
+		: { mutation: { mutationKey } };
+
+	const mutationFn: MutationFunction<
+		Awaited<ReturnType<typeof updatePublicDashboardV2>>,
+		{
+			pathParams: UpdatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updatePublicDashboardV2(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdatePublicDashboardV2MutationResult = NonNullable<
+	Awaited<ReturnType<typeof updatePublicDashboardV2>>
+>;
+export type UpdatePublicDashboardV2MutationBody =
+	BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+export type UpdatePublicDashboardV2MutationError =
+	ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update public sharing config for a dashboard v2
+ */
+export const useUpdatePublicDashboardV2 = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown,
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updatePublicDashboardV2>>,
+		TError,
+		{
+			pathParams: UpdatePublicDashboardV2PathParameters;
+			data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updatePublicDashboardV2>>,
+	TError,
+	{
+		pathParams: UpdatePublicDashboardV2PathParameters;
+		data: BodyType<DashboardtypesUpdatablePublicDashboardDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdatePublicDashboardV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
+};

frontend/src/api/generated/services/downtimeschedules/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -112,7 +111,9 @@ export function useListDowntimeSchedules<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -136,7 +137,7 @@ export const invalidateListDowntimeSchedules = async (
  * @summary Create downtime schedule
  */
 export const createDowntimeSchedule = (
-	ruletypesPostablePlannedMaintenanceDTO?: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
+	ruletypesPostablePlannedMaintenanceDTO: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateDowntimeSchedule201>({
@@ -155,13 +156,13 @@ export const getCreateDowntimeScheduleMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+		{ data: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+	{ data: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
 	TContext
 > => {
 	const mutationKey = ['createDowntimeSchedule'];
@@ -175,7 +176,7 @@ export const getCreateDowntimeScheduleMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> }
+		{ data: BodyType<RuletypesPostablePlannedMaintenanceDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -189,8 +190,7 @@ export type CreateDowntimeScheduleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>
 >;
 export type CreateDowntimeScheduleMutationBody =
-	| BodyType<RuletypesPostablePlannedMaintenanceDTO>
-	| undefined;
+	BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 export type CreateDowntimeScheduleMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -204,29 +204,29 @@ export const useCreateDowntimeSchedule = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createDowntimeSchedule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+		{ data: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createDowntimeSchedule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
+	{ data: BodyType<RuletypesPostablePlannedMaintenanceDTO> },
 	TContext
 > => {
-	return useMutation(getCreateDowntimeScheduleMutationOptions(options));
+	const mutationOptions = getCreateDowntimeScheduleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes a downtime schedule by ID
  * @summary Delete downtime schedule
  */
-export const deleteDowntimeScheduleByID = (
-	{ id }: DeleteDowntimeScheduleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteDowntimeScheduleByID = ({
+	id,
+}: DeleteDowntimeScheduleByIDPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/downtime_schedules/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -293,7 +293,9 @@ export const useDeleteDowntimeScheduleByID = <
 	{ pathParams: DeleteDowntimeScheduleByIDPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteDowntimeScheduleByIDMutationOptions(options));
+	const mutationOptions = getDeleteDowntimeScheduleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns a downtime schedule by ID
@@ -379,7 +381,9 @@ export function useGetDowntimeScheduleByID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -404,15 +408,13 @@ export const invalidateGetDowntimeScheduleByID = async (
  */
 export const updateDowntimeScheduleByID = (
 	{ id }: UpdateDowntimeScheduleByIDPathParameters,
-	ruletypesPostablePlannedMaintenanceDTO?: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
-	signal?: AbortSignal,
+	ruletypesPostablePlannedMaintenanceDTO: BodyType<RuletypesPostablePlannedMaintenanceDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/downtime_schedules/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: ruletypesPostablePlannedMaintenanceDTO,
-		signal,
 	});
 };
 
@@ -425,7 +427,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 		},
 		TContext
 	>;
@@ -434,7 +436,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+		data: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 	},
 	TContext
 > => {
@@ -451,7 +453,7 @@ export const getUpdateDowntimeScheduleByIDMutationOptions = <
 		Awaited<ReturnType<typeof updateDowntimeScheduleByID>>,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -466,8 +468,7 @@ export type UpdateDowntimeScheduleByIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateDowntimeScheduleByID>>
 >;
 export type UpdateDowntimeScheduleByIDMutationBody =
-	| BodyType<RuletypesPostablePlannedMaintenanceDTO>
-	| undefined;
+	BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 export type UpdateDowntimeScheduleByIDMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -483,7 +484,7 @@ export const useUpdateDowntimeScheduleByID = <
 		TError,
 		{
 			pathParams: UpdateDowntimeScheduleByIDPathParameters;
-			data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+			data: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 		},
 		TContext
 	>;
@@ -492,9 +493,11 @@ export const useUpdateDowntimeScheduleByID = <
 	TError,
 	{
 		pathParams: UpdateDowntimeScheduleByIDPathParameters;
-		data?: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
+		data: BodyType<RuletypesPostablePlannedMaintenanceDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateDowntimeScheduleByIDMutationOptions(options));
+	const mutationOptions = getUpdateDowntimeScheduleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/features/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useQuery } from 'react-query';
 import type {
@@ -86,7 +85,9 @@ export function useGetFeatures<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/fields/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useQuery } from 'react-query';
 import type {
@@ -102,7 +101,9 @@ export function useGetFieldsKeys<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -197,7 +198,9 @@ export function useGetFieldsValues<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/gateway/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -120,7 +119,9 @@ export function useGetIngestionKeys<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -144,7 +145,7 @@ export const invalidateGetIngestionKeys = async (
  * @summary Create ingestion key for workspace
  */
 export const createIngestionKey = (
-	gatewaytypesPostableIngestionKeyDTO?: BodyType<GatewaytypesPostableIngestionKeyDTO>,
+	gatewaytypesPostableIngestionKeyDTO: BodyType<GatewaytypesPostableIngestionKeyDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateIngestionKey201>({
@@ -163,13 +164,13 @@ export const getCreateIngestionKeyMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createIngestionKey>>,
 		TError,
-		{ data?: BodyType<GatewaytypesPostableIngestionKeyDTO> },
+		{ data: BodyType<GatewaytypesPostableIngestionKeyDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createIngestionKey>>,
 	TError,
-	{ data?: BodyType<GatewaytypesPostableIngestionKeyDTO> },
+	{ data: BodyType<GatewaytypesPostableIngestionKeyDTO> },
 	TContext
 > => {
 	const mutationKey = ['createIngestionKey'];
@@ -183,7 +184,7 @@ export const getCreateIngestionKeyMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createIngestionKey>>,
-		{ data?: BodyType<GatewaytypesPostableIngestionKeyDTO> }
+		{ data: BodyType<GatewaytypesPostableIngestionKeyDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -197,8 +198,7 @@ export type CreateIngestionKeyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createIngestionKey>>
 >;
 export type CreateIngestionKeyMutationBody =
-	| BodyType<GatewaytypesPostableIngestionKeyDTO>
-	| undefined;
+	BodyType<GatewaytypesPostableIngestionKeyDTO>;
 export type CreateIngestionKeyMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -211,29 +211,29 @@ export const useCreateIngestionKey = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createIngestionKey>>,
 		TError,
-		{ data?: BodyType<GatewaytypesPostableIngestionKeyDTO> },
+		{ data: BodyType<GatewaytypesPostableIngestionKeyDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createIngestionKey>>,
 	TError,
-	{ data?: BodyType<GatewaytypesPostableIngestionKeyDTO> },
+	{ data: BodyType<GatewaytypesPostableIngestionKeyDTO> },
 	TContext
 > => {
-	return useMutation(getCreateIngestionKeyMutationOptions(options));
+	const mutationOptions = getCreateIngestionKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes an ingestion key for the workspace
  * @summary Delete ingestion key for workspace
  */
-export const deleteIngestionKey = (
-	{ keyId }: DeleteIngestionKeyPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteIngestionKey = ({
+	keyId,
+}: DeleteIngestionKeyPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/gateway/ingestion_keys/${keyId}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -299,7 +299,9 @@ export const useDeleteIngestionKey = <
 	{ pathParams: DeleteIngestionKeyPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteIngestionKeyMutationOptions(options));
+	const mutationOptions = getDeleteIngestionKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates an ingestion key for the workspace
@@ -307,15 +309,13 @@ export const useDeleteIngestionKey = <
  */
 export const updateIngestionKey = (
 	{ keyId }: UpdateIngestionKeyPathParameters,
-	gatewaytypesPostableIngestionKeyDTO?: BodyType<GatewaytypesPostableIngestionKeyDTO>,
-	signal?: AbortSignal,
+	gatewaytypesPostableIngestionKeyDTO: BodyType<GatewaytypesPostableIngestionKeyDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/gateway/ingestion_keys/${keyId}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: gatewaytypesPostableIngestionKeyDTO,
-		signal,
 	});
 };
 
@@ -328,7 +328,7 @@ export const getUpdateIngestionKeyMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateIngestionKeyPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyDTO>;
 		},
 		TContext
 	>;
@@ -337,7 +337,7 @@ export const getUpdateIngestionKeyMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateIngestionKeyPathParameters;
-		data?: BodyType<GatewaytypesPostableIngestionKeyDTO>;
+		data: BodyType<GatewaytypesPostableIngestionKeyDTO>;
 	},
 	TContext
 > => {
@@ -354,7 +354,7 @@ export const getUpdateIngestionKeyMutationOptions = <
 		Awaited<ReturnType<typeof updateIngestionKey>>,
 		{
 			pathParams: UpdateIngestionKeyPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -369,8 +369,7 @@ export type UpdateIngestionKeyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateIngestionKey>>
 >;
 export type UpdateIngestionKeyMutationBody =
-	| BodyType<GatewaytypesPostableIngestionKeyDTO>
-	| undefined;
+	BodyType<GatewaytypesPostableIngestionKeyDTO>;
 export type UpdateIngestionKeyMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -385,7 +384,7 @@ export const useUpdateIngestionKey = <
 		TError,
 		{
 			pathParams: UpdateIngestionKeyPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyDTO>;
 		},
 		TContext
 	>;
@@ -394,11 +393,13 @@ export const useUpdateIngestionKey = <
 	TError,
 	{
 		pathParams: UpdateIngestionKeyPathParameters;
-		data?: BodyType<GatewaytypesPostableIngestionKeyDTO>;
+		data: BodyType<GatewaytypesPostableIngestionKeyDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateIngestionKeyMutationOptions(options));
+	const mutationOptions = getUpdateIngestionKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint creates an ingestion key limit
@@ -406,7 +407,7 @@ export const useUpdateIngestionKey = <
  */
 export const createIngestionKeyLimit = (
 	{ keyId }: CreateIngestionKeyLimitPathParameters,
-	gatewaytypesPostableIngestionKeyLimitDTO?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>,
+	gatewaytypesPostableIngestionKeyLimitDTO: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateIngestionKeyLimit201>({
@@ -427,7 +428,7 @@ export const getCreateIngestionKeyLimitMutationOptions = <
 		TError,
 		{
 			pathParams: CreateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 		},
 		TContext
 	>;
@@ -436,7 +437,7 @@ export const getCreateIngestionKeyLimitMutationOptions = <
 	TError,
 	{
 		pathParams: CreateIngestionKeyLimitPathParameters;
-		data?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
+		data: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 	},
 	TContext
 > => {
@@ -453,7 +454,7 @@ export const getCreateIngestionKeyLimitMutationOptions = <
 		Awaited<ReturnType<typeof createIngestionKeyLimit>>,
 		{
 			pathParams: CreateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -468,8 +469,7 @@ export type CreateIngestionKeyLimitMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createIngestionKeyLimit>>
 >;
 export type CreateIngestionKeyLimitMutationBody =
-	| BodyType<GatewaytypesPostableIngestionKeyLimitDTO>
-	| undefined;
+	BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 export type CreateIngestionKeyLimitMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -485,7 +485,7 @@ export const useCreateIngestionKeyLimit = <
 		TError,
 		{
 			pathParams: CreateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 		},
 		TContext
 	>;
@@ -494,24 +494,24 @@ export const useCreateIngestionKeyLimit = <
 	TError,
 	{
 		pathParams: CreateIngestionKeyLimitPathParameters;
-		data?: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
+		data: BodyType<GatewaytypesPostableIngestionKeyLimitDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreateIngestionKeyLimitMutationOptions(options));
+	const mutationOptions = getCreateIngestionKeyLimitMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes an ingestion key limit
  * @summary Delete limit for the ingestion key
  */
-export const deleteIngestionKeyLimit = (
-	{ limitId }: DeleteIngestionKeyLimitPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteIngestionKeyLimit = ({
+	limitId,
+}: DeleteIngestionKeyLimitPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/gateway/ingestion_keys/limits/${limitId}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -578,7 +578,9 @@ export const useDeleteIngestionKeyLimit = <
 	{ pathParams: DeleteIngestionKeyLimitPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteIngestionKeyLimitMutationOptions(options));
+	const mutationOptions = getDeleteIngestionKeyLimitMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates an ingestion key limit
@@ -586,15 +588,13 @@ export const useDeleteIngestionKeyLimit = <
  */
 export const updateIngestionKeyLimit = (
 	{ limitId }: UpdateIngestionKeyLimitPathParameters,
-	gatewaytypesUpdatableIngestionKeyLimitDTO?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>,
-	signal?: AbortSignal,
+	gatewaytypesUpdatableIngestionKeyLimitDTO: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/gateway/ingestion_keys/limits/${limitId}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: gatewaytypesUpdatableIngestionKeyLimitDTO,
-		signal,
 	});
 };
 
@@ -607,7 +607,7 @@ export const getUpdateIngestionKeyLimitMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 		},
 		TContext
 	>;
@@ -616,7 +616,7 @@ export const getUpdateIngestionKeyLimitMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateIngestionKeyLimitPathParameters;
-		data?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
+		data: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 	},
 	TContext
 > => {
@@ -633,7 +633,7 @@ export const getUpdateIngestionKeyLimitMutationOptions = <
 		Awaited<ReturnType<typeof updateIngestionKeyLimit>>,
 		{
 			pathParams: UpdateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -648,8 +648,7 @@ export type UpdateIngestionKeyLimitMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateIngestionKeyLimit>>
 >;
 export type UpdateIngestionKeyLimitMutationBody =
-	| BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>
-	| undefined;
+	BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 export type UpdateIngestionKeyLimitMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -665,7 +664,7 @@ export const useUpdateIngestionKeyLimit = <
 		TError,
 		{
 			pathParams: UpdateIngestionKeyLimitPathParameters;
-			data?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
+			data: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 		},
 		TContext
 	>;
@@ -674,11 +673,13 @@ export const useUpdateIngestionKeyLimit = <
 	TError,
 	{
 		pathParams: UpdateIngestionKeyLimitPathParameters;
-		data?: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
+		data: BodyType<GatewaytypesUpdatableIngestionKeyLimitDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateIngestionKeyLimitMutationOptions(options));
+	const mutationOptions = getUpdateIngestionKeyLimitMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the ingestion keys for a workspace
@@ -762,7 +763,9 @@ export function useSearchIngestionKeys<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/global/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useQuery } from 'react-query';
 import type {
@@ -89,7 +88,9 @@ export function useGetGlobalConfig<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/health/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useQuery } from 'react-query';
 import type {
@@ -84,7 +83,9 @@ export function useHealthz<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -157,7 +158,9 @@ export function useLivez<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -227,7 +230,9 @@ export function useReadyz<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/inframonitoring/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation } from 'react-query';
 import type {
@@ -13,113 +12,26 @@ import type {
 } from 'react-query';
 
 import type {
-	InframonitoringtypesPostableClustersDTO,
 	InframonitoringtypesPostableHostsDTO,
 	InframonitoringtypesPostableNamespacesDTO,
 	InframonitoringtypesPostableNodesDTO,
 	InframonitoringtypesPostablePodsDTO,
-	InframonitoringtypesPostableVolumesDTO,
-	ListClusters200,
 	ListHosts200,
 	ListNamespaces200,
 	ListNodes200,
 	ListPods200,
-	ListVolumes200,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';
 
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
-/**
- * Returns a paginated list of Kubernetes clusters with key aggregated metrics derived by summing per-node values within the group: CPU usage, CPU allocatable, memory working set, memory allocatable. Each row also reports per-group nodeCountsByReadiness ({ ready, notReady } from each node's latest k8s.node.condition_ready value) and per-group podCountsByPhase ({ pending, running, succeeded, failed, unknown } from each pod's latest k8s.pod.phase value). Each cluster includes metadata attributes (k8s.cluster.name). The response type is 'list' for the default k8s.cluster.name grouping or 'grouped_list' for custom groupBy keys; in both modes every row aggregates nodes and pods in the group. Supports filtering via a filter expression, custom groupBy, ordering by cpu / cpu_allocatable / memory / memory_allocatable, and pagination via offset/limit. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (clusterCPU, clusterCPUAllocatable, clusterMemory, clusterMemoryAllocatable) return -1 as a sentinel when no data is available for that field.
- * @summary List Clusters for Infra Monitoring
- */
-export const listClusters = (
-	inframonitoringtypesPostableClustersDTO?: BodyType<InframonitoringtypesPostableClustersDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListClusters200>({
-		url: `/api/v2/infra_monitoring/clusters`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: inframonitoringtypesPostableClustersDTO,
-		signal,
-	});
-};
-
-export const getListClustersMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listClusters>>,
-		TError,
-		{ data?: BodyType<InframonitoringtypesPostableClustersDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof listClusters>>,
-	TError,
-	{ data?: BodyType<InframonitoringtypesPostableClustersDTO> },
-	TContext
-> => {
-	const mutationKey = ['listClusters'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof listClusters>>,
-		{ data?: BodyType<InframonitoringtypesPostableClustersDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return listClusters(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ListClustersMutationResult = NonNullable<
-	Awaited<ReturnType<typeof listClusters>>
->;
-export type ListClustersMutationBody =
-	| BodyType<InframonitoringtypesPostableClustersDTO>
-	| undefined;
-export type ListClustersMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List Clusters for Infra Monitoring
- */
-export const useListClusters = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listClusters>>,
-		TError,
-		{ data?: BodyType<InframonitoringtypesPostableClustersDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof listClusters>>,
-	TError,
-	{ data?: BodyType<InframonitoringtypesPostableClustersDTO> },
-	TContext
-> => {
-	return useMutation(getListClustersMutationOptions(options));
-};
 /**
  * Returns a paginated list of hosts with key infrastructure metrics: CPU usage (%), memory usage (%), I/O wait (%), disk usage (%), and 15-minute load average. Each host includes its current status (active/inactive based on metrics reported in the last 10 minutes) and metadata attributes (e.g., os.type). Supports filtering via a filter expression, filtering by host status, custom groupBy to aggregate hosts by any attribute, ordering by any of the five metrics, and pagination via offset/limit. The response type is 'list' for the default host.name grouping or 'grouped_list' for custom groupBy keys. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (cpu, memory, wait, load15, diskUsage) return -1 as a sentinel when no data is available for that field.
  * @summary List Hosts for Infra Monitoring
  */
 export const listHosts = (
-	inframonitoringtypesPostableHostsDTO?: BodyType<InframonitoringtypesPostableHostsDTO>,
+	inframonitoringtypesPostableHostsDTO: BodyType<InframonitoringtypesPostableHostsDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ListHosts200>({
@@ -138,13 +50,13 @@ export const getListHostsMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listHosts>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableHostsDTO> },
+		{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof listHosts>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableHostsDTO> },
+	{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
 	TContext
 > => {
 	const mutationKey = ['listHosts'];
@@ -158,7 +70,7 @@ export const getListHostsMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof listHosts>>,
-		{ data?: BodyType<InframonitoringtypesPostableHostsDTO> }
+		{ data: BodyType<InframonitoringtypesPostableHostsDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -172,8 +84,7 @@ export type ListHostsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof listHosts>>
 >;
 export type ListHostsMutationBody =
-	| BodyType<InframonitoringtypesPostableHostsDTO>
-	| undefined;
+	BodyType<InframonitoringtypesPostableHostsDTO>;
 export type ListHostsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -186,23 +97,25 @@ export const useListHosts = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listHosts>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableHostsDTO> },
+		{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof listHosts>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableHostsDTO> },
+	{ data: BodyType<InframonitoringtypesPostableHostsDTO> },
 	TContext
 > => {
-	return useMutation(getListHostsMutationOptions(options));
+	const mutationOptions = getListHostsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns a paginated list of Kubernetes namespaces with key aggregated pod metrics: CPU usage and memory working set (summed across pods in the group), plus per-group podCountsByPhase ({ pending, running, succeeded, failed, unknown } from each pod's latest k8s.pod.phase value in the window). Each namespace includes metadata attributes (k8s.namespace.name, k8s.cluster.name). The response type is 'list' for the default k8s.namespace.name grouping or 'grouped_list' for custom groupBy keys; in both modes every row aggregates pods in the group. Supports filtering via a filter expression, custom groupBy, ordering by cpu / memory, and pagination via offset/limit. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (namespaceCPU, namespaceMemory) return -1 as a sentinel when no data is available for that field.
  * @summary List Namespaces for Infra Monitoring
  */
 export const listNamespaces = (
-	inframonitoringtypesPostableNamespacesDTO?: BodyType<InframonitoringtypesPostableNamespacesDTO>,
+	inframonitoringtypesPostableNamespacesDTO: BodyType<InframonitoringtypesPostableNamespacesDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ListNamespaces200>({
@@ -221,13 +134,13 @@ export const getListNamespacesMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listNamespaces>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableNamespacesDTO> },
+		{ data: BodyType<InframonitoringtypesPostableNamespacesDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof listNamespaces>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableNamespacesDTO> },
+	{ data: BodyType<InframonitoringtypesPostableNamespacesDTO> },
 	TContext
 > => {
 	const mutationKey = ['listNamespaces'];
@@ -241,7 +154,7 @@ export const getListNamespacesMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof listNamespaces>>,
-		{ data?: BodyType<InframonitoringtypesPostableNamespacesDTO> }
+		{ data: BodyType<InframonitoringtypesPostableNamespacesDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -255,8 +168,7 @@ export type ListNamespacesMutationResult = NonNullable<
 	Awaited<ReturnType<typeof listNamespaces>>
 >;
 export type ListNamespacesMutationBody =
-	| BodyType<InframonitoringtypesPostableNamespacesDTO>
-	| undefined;
+	BodyType<InframonitoringtypesPostableNamespacesDTO>;
 export type ListNamespacesMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -269,23 +181,25 @@ export const useListNamespaces = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listNamespaces>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableNamespacesDTO> },
+		{ data: BodyType<InframonitoringtypesPostableNamespacesDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof listNamespaces>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableNamespacesDTO> },
+	{ data: BodyType<InframonitoringtypesPostableNamespacesDTO> },
 	TContext
 > => {
-	return useMutation(getListNamespacesMutationOptions(options));
+	const mutationOptions = getListNamespacesMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns a paginated list of Kubernetes nodes with key metrics: CPU usage, CPU allocatable, memory working set, memory allocatable, per-group nodeCountsByReadiness ({ ready, notReady } from each node's latest k8s.node.condition_ready in the window) and per-group podCountsByPhase ({ pending, running, succeeded, failed, unknown } for pods scheduled on the listed nodes). Each node includes metadata attributes (k8s.node.uid, k8s.cluster.name). The response type is 'list' for the default k8s.node.name grouping (each row is one node with its current condition string: ready / not_ready / no_data) or 'grouped_list' for custom groupBy keys (each row aggregates nodes in the group; condition stays no_data). Supports filtering via a filter expression, custom groupBy, ordering by cpu / cpu_allocatable / memory / memory_allocatable, and pagination via offset/limit. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (nodeCPU, nodeCPUAllocatable, nodeMemory, nodeMemoryAllocatable) return -1 as a sentinel when no data is available for that field.
  * @summary List Nodes for Infra Monitoring
  */
 export const listNodes = (
-	inframonitoringtypesPostableNodesDTO?: BodyType<InframonitoringtypesPostableNodesDTO>,
+	inframonitoringtypesPostableNodesDTO: BodyType<InframonitoringtypesPostableNodesDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ListNodes200>({
@@ -304,13 +218,13 @@ export const getListNodesMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listNodes>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableNodesDTO> },
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof listNodes>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableNodesDTO> },
+	{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
 	TContext
 > => {
 	const mutationKey = ['listNodes'];
@@ -324,7 +238,7 @@ export const getListNodesMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof listNodes>>,
-		{ data?: BodyType<InframonitoringtypesPostableNodesDTO> }
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -338,8 +252,7 @@ export type ListNodesMutationResult = NonNullable<
 	Awaited<ReturnType<typeof listNodes>>
 >;
 export type ListNodesMutationBody =
-	| BodyType<InframonitoringtypesPostableNodesDTO>
-	| undefined;
+	BodyType<InframonitoringtypesPostableNodesDTO>;
 export type ListNodesMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -352,23 +265,25 @@ export const useListNodes = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listNodes>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostableNodesDTO> },
+		{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof listNodes>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostableNodesDTO> },
+	{ data: BodyType<InframonitoringtypesPostableNodesDTO> },
 	TContext
 > => {
-	return useMutation(getListNodesMutationOptions(options));
+	const mutationOptions = getListNodesMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns a paginated list of Kubernetes pods with key metrics: CPU usage, CPU request/limit utilization, memory working set, memory request/limit utilization, current pod phase (pending/running/succeeded/failed/unknown/no_data), and pod age (ms since start time). Each pod includes metadata attributes (namespace, node, workload owner such as deployment/statefulset/daemonset/job/cronjob, cluster). Supports filtering via a filter expression, custom groupBy to aggregate pods by any attribute, ordering by any of the six metrics (cpu, cpu_request, cpu_limit, memory, memory_request, memory_limit), and pagination via offset/limit. The response type is 'list' for the default k8s.pod.uid grouping (each row is one pod with its current phase) or 'grouped_list' for custom groupBy keys (each row aggregates pods in the group with per-phase counts under podCountsByPhase: { pending, running, succeeded, failed, unknown } derived from each pod's latest phase in the window). Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (podCPU, podCPURequest, podCPULimit, podMemory, podMemoryRequest, podMemoryLimit, podAge) return -1 as a sentinel when no data is available for that field.
  * @summary List Pods for Infra Monitoring
  */
 export const listPods = (
-	inframonitoringtypesPostablePodsDTO?: BodyType<InframonitoringtypesPostablePodsDTO>,
+	inframonitoringtypesPostablePodsDTO: BodyType<InframonitoringtypesPostablePodsDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ListPods200>({
@@ -387,13 +302,13 @@ export const getListPodsMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listPods>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostablePodsDTO> },
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof listPods>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostablePodsDTO> },
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
 	TContext
 > => {
 	const mutationKey = ['listPods'];
@@ -407,7 +322,7 @@ export const getListPodsMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof listPods>>,
-		{ data?: BodyType<InframonitoringtypesPostablePodsDTO> }
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -421,8 +336,7 @@ export type ListPodsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof listPods>>
 >;
 export type ListPodsMutationBody =
-	| BodyType<InframonitoringtypesPostablePodsDTO>
-	| undefined;
+	BodyType<InframonitoringtypesPostablePodsDTO>;
 export type ListPodsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -435,97 +349,16 @@ export const useListPods = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof listPods>>,
 		TError,
-		{ data?: BodyType<InframonitoringtypesPostablePodsDTO> },
+		{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof listPods>>,
 	TError,
-	{ data?: BodyType<InframonitoringtypesPostablePodsDTO> },
+	{ data: BodyType<InframonitoringtypesPostablePodsDTO> },
 	TContext
 > => {
-	return useMutation(getListPodsMutationOptions(options));
-};
-/**
- * Returns a paginated list of Kubernetes persistent volume claims (PVCs) with key volume metrics: available bytes, capacity bytes, usage (capacity - available), inodes, free inodes, and used inodes. Each row also includes metadata attributes (k8s.persistentvolumeclaim.name, k8s.pod.uid, k8s.pod.name, k8s.namespace.name, k8s.node.name, k8s.statefulset.name, k8s.cluster.name). Supports filtering via a filter expression, custom groupBy to aggregate volumes by any attribute, ordering by any of the six metrics (available, capacity, usage, inodes, inodes_free, inodes_used), and pagination via offset/limit. The response type is 'list' for the default k8s.persistentvolumeclaim.name grouping or 'grouped_list' for custom groupBy keys; in both modes every row aggregates volumes in the group. Also reports missing required metrics and whether the requested time range falls before the data retention boundary. Numeric metric fields (volumeAvailable, volumeCapacity, volumeUsage, volumeInodes, volumeInodesFree, volumeInodesUsed) return -1 as a sentinel when no data is available for that field.
- * @summary List Volumes for Infra Monitoring
- */
-export const listVolumes = (
-	inframonitoringtypesPostableVolumesDTO?: BodyType<InframonitoringtypesPostableVolumesDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListVolumes200>({
-		url: `/api/v2/infra_monitoring/pvcs`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: inframonitoringtypesPostableVolumesDTO,
-		signal,
-	});
-};
-
-export const getListVolumesMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listVolumes>>,
-		TError,
-		{ data?: BodyType<InframonitoringtypesPostableVolumesDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof listVolumes>>,
-	TError,
-	{ data?: BodyType<InframonitoringtypesPostableVolumesDTO> },
-	TContext
-> => {
-	const mutationKey = ['listVolumes'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof listVolumes>>,
-		{ data?: BodyType<InframonitoringtypesPostableVolumesDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return listVolumes(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type ListVolumesMutationResult = NonNullable<
-	Awaited<ReturnType<typeof listVolumes>>
->;
-export type ListVolumesMutationBody =
-	| BodyType<InframonitoringtypesPostableVolumesDTO>
-	| undefined;
-export type ListVolumesMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List Volumes for Infra Monitoring
- */
-export const useListVolumes = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof listVolumes>>,
-		TError,
-		{ data?: BodyType<InframonitoringtypesPostableVolumesDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof listVolumes>>,
-	TError,
-	{ data?: BodyType<InframonitoringtypesPostableVolumesDTO> },
-	TContext
-> => {
-	return useMutation(getListVolumesMutationOptions(options));
+	const mutationOptions = getListPodsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/llmpricingrules/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -110,7 +109,9 @@ export function useListLLMPricingRules<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -134,15 +135,13 @@ export const invalidateListLLMPricingRules = async (
  * @summary Create or update pricing rules
  */
 export const createOrUpdateLLMPricingRules = (
-	llmpricingruletypesUpdatableLLMPricingRulesDTO?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>,
-	signal?: AbortSignal,
+	llmpricingruletypesUpdatableLLMPricingRulesDTO: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/llm_pricing_rules`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: llmpricingruletypesUpdatableLLMPricingRulesDTO,
-		signal,
 	});
 };
 
@@ -153,13 +152,13 @@ export const getCreateOrUpdateLLMPricingRulesMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>,
 		TError,
-		{ data?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
+		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>,
 	TError,
-	{ data?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
+	{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
 	TContext
 > => {
 	const mutationKey = ['createOrUpdateLLMPricingRules'];
@@ -173,7 +172,7 @@ export const getCreateOrUpdateLLMPricingRulesMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>,
-		{ data?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> }
+		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -187,8 +186,7 @@ export type CreateOrUpdateLLMPricingRulesMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>
 >;
 export type CreateOrUpdateLLMPricingRulesMutationBody =
-	| BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>
-	| undefined;
+	BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO>;
 export type CreateOrUpdateLLMPricingRulesMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -202,29 +200,30 @@ export const useCreateOrUpdateLLMPricingRules = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>,
 		TError,
-		{ data?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
+		{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createOrUpdateLLMPricingRules>>,
 	TError,
-	{ data?: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
+	{ data: BodyType<LlmpricingruletypesUpdatableLLMPricingRulesDTO> },
 	TContext
 > => {
-	return useMutation(getCreateOrUpdateLLMPricingRulesMutationOptions(options));
+	const mutationOptions =
+		getCreateOrUpdateLLMPricingRulesMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Hard-deletes a pricing rule. If auto-synced, it will be recreated on the next sync cycle.
  * @summary Delete a pricing rule
  */
-export const deleteLLMPricingRule = (
-	{ id }: DeleteLLMPricingRulePathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteLLMPricingRule = ({
+	id,
+}: DeleteLLMPricingRulePathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/llm_pricing_rules/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -291,7 +290,9 @@ export const useDeleteLLMPricingRule = <
 	{ pathParams: DeleteLLMPricingRulePathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteLLMPricingRuleMutationOptions(options));
+	const mutationOptions = getDeleteLLMPricingRuleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns a single LLM pricing rule by ID.
@@ -376,7 +377,9 @@ export function useGetLLMPricingRule<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**

frontend/src/api/generated/services/logs/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -34,7 +33,7 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  * @summary Export raw data
  */
 export const handleExportRawDataPOST = (
-	querybuildertypesv5QueryRangeRequestDTO?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
+	querybuildertypesv5QueryRangeRequestDTO: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
 	params?: HandleExportRawDataPOSTParams,
 	signal?: AbortSignal,
 ) => {
@@ -56,7 +55,7 @@ export const getHandleExportRawDataPOSTMutationOptions = <
 		Awaited<ReturnType<typeof handleExportRawDataPOST>>,
 		TError,
 		{
-			data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 			params?: HandleExportRawDataPOSTParams;
 		},
 		TContext
@@ -65,7 +64,7 @@ export const getHandleExportRawDataPOSTMutationOptions = <
 	Awaited<ReturnType<typeof handleExportRawDataPOST>>,
 	TError,
 	{
-		data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+		data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 		params?: HandleExportRawDataPOSTParams;
 	},
 	TContext
@@ -82,7 +81,7 @@ export const getHandleExportRawDataPOSTMutationOptions = <
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof handleExportRawDataPOST>>,
 		{
-			data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 			params?: HandleExportRawDataPOSTParams;
 		}
 	> = (props) => {
@@ -98,8 +97,7 @@ export type HandleExportRawDataPOSTMutationResult = NonNullable<
 	Awaited<ReturnType<typeof handleExportRawDataPOST>>
 >;
 export type HandleExportRawDataPOSTMutationBody =
-	| BodyType<Querybuildertypesv5QueryRangeRequestDTO>
-	| undefined;
+	BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 export type HandleExportRawDataPOSTMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -114,7 +112,7 @@ export const useHandleExportRawDataPOST = <
 		Awaited<ReturnType<typeof handleExportRawDataPOST>>,
 		TError,
 		{
-			data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+			data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 			params?: HandleExportRawDataPOSTParams;
 		},
 		TContext
@@ -123,12 +121,14 @@ export const useHandleExportRawDataPOST = <
 	Awaited<ReturnType<typeof handleExportRawDataPOST>>,
 	TError,
 	{
-		data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
+		data: BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 		params?: HandleExportRawDataPOSTParams;
 	},
 	TContext
 > => {
-	return useMutation(getHandleExportRawDataPOSTMutationOptions(options));
+	const mutationOptions = getHandleExportRawDataPOSTMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoints promotes and indexes paths
@@ -198,7 +198,9 @@ export function useListPromotedAndIndexedPaths<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -221,7 +223,7 @@ export const invalidateListPromotedAndIndexedPaths = async (
  * @summary Promote and index paths
  */
 export const handlePromoteAndIndexPaths = (
-	promotetypesPromotePathDTONull?: BodyType<
+	promotetypesPromotePathDTONull: BodyType<
 		PromotetypesPromotePathDTO[] | null
 	> | null,
 	signal?: AbortSignal,
@@ -242,13 +244,13 @@ export const getHandlePromoteAndIndexPathsMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>,
 		TError,
-		{ data?: BodyType<PromotetypesPromotePathDTO[] | null> },
+		{ data: BodyType<PromotetypesPromotePathDTO[] | null> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>,
 	TError,
-	{ data?: BodyType<PromotetypesPromotePathDTO[] | null> },
+	{ data: BodyType<PromotetypesPromotePathDTO[] | null> },
 	TContext
 > => {
 	const mutationKey = ['handlePromoteAndIndexPaths'];
@@ -262,7 +264,7 @@ export const getHandlePromoteAndIndexPathsMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>,
-		{ data?: BodyType<PromotetypesPromotePathDTO[] | null> }
+		{ data: BodyType<PromotetypesPromotePathDTO[] | null> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -275,9 +277,9 @@ export const getHandlePromoteAndIndexPathsMutationOptions = <
 export type HandlePromoteAndIndexPathsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>
 >;
-export type HandlePromoteAndIndexPathsMutationBody =
-	| BodyType<PromotetypesPromotePathDTO[] | null>
-	| undefined;
+export type HandlePromoteAndIndexPathsMutationBody = BodyType<
+	PromotetypesPromotePathDTO[] | null
+>;
 export type HandlePromoteAndIndexPathsMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -291,14 +293,16 @@ export const useHandlePromoteAndIndexPaths = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>,
 		TError,
-		{ data?: BodyType<PromotetypesPromotePathDTO[] | null> },
+		{ data: BodyType<PromotetypesPromotePathDTO[] | null> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof handlePromoteAndIndexPaths>>,
 	TError,
-	{ data?: BodyType<PromotetypesPromotePathDTO[] | null> },
+	{ data: BodyType<PromotetypesPromotePathDTO[] | null> },
 	TContext
 > => {
-	return useMutation(getHandlePromoteAndIndexPathsMutationOptions(options));
+	const mutationOptions = getHandlePromoteAndIndexPathsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/metrics/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -123,7 +122,9 @@ export function useListMetrics<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -225,7 +226,9 @@ export function useGetMetricAlerts<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -340,7 +343,9 @@ export function useGetMetricAttributes<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -446,7 +451,9 @@ export function useGetMetricDashboards<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -551,7 +558,9 @@ export function useGetMetricHighlights<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -653,7 +662,9 @@ export function useGetMetricMetadata<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -678,7 +689,7 @@ export const invalidateGetMetricMetadata = async (
  */
 export const updateMetricMetadata = (
 	{ metricName }: UpdateMetricMetadataPathParameters,
-	metricsexplorertypesUpdateMetricMetadataRequestDTO?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>,
+	metricsexplorertypesUpdateMetricMetadataRequestDTO: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<string>({
@@ -699,7 +710,7 @@ export const getUpdateMetricMetadataMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateMetricMetadataPathParameters;
-			data?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
+			data: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 		},
 		TContext
 	>;
@@ -708,7 +719,7 @@ export const getUpdateMetricMetadataMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateMetricMetadataPathParameters;
-		data?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
+		data: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 	},
 	TContext
 > => {
@@ -725,7 +736,7 @@ export const getUpdateMetricMetadataMutationOptions = <
 		Awaited<ReturnType<typeof updateMetricMetadata>>,
 		{
 			pathParams: UpdateMetricMetadataPathParameters;
-			data?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
+			data: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -740,8 +751,7 @@ export type UpdateMetricMetadataMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateMetricMetadata>>
 >;
 export type UpdateMetricMetadataMutationBody =
-	| BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>
-	| undefined;
+	BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 export type UpdateMetricMetadataMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -757,7 +767,7 @@ export const useUpdateMetricMetadata = <
 		TError,
 		{
 			pathParams: UpdateMetricMetadataPathParameters;
-			data?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
+			data: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 		},
 		TContext
 	>;
@@ -766,18 +776,20 @@ export const useUpdateMetricMetadata = <
 	TError,
 	{
 		pathParams: UpdateMetricMetadataPathParameters;
-		data?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
+		data: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateMetricMetadataMutationOptions(options));
+	const mutationOptions = getUpdateMetricMetadataMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns raw time series data points for a metric within a time range (max 30 minutes). Each series includes labels and timestamp/value pairs.
  * @summary Inspect raw metric data points
  */
 export const inspectMetrics = (
-	metricsexplorertypesInspectMetricsRequestDTO?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO>,
+	metricsexplorertypesInspectMetricsRequestDTO: BodyType<MetricsexplorertypesInspectMetricsRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<InspectMetrics200>({
@@ -796,13 +808,13 @@ export const getInspectMetricsMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof inspectMetrics>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof inspectMetrics>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['inspectMetrics'];
@@ -816,7 +828,7 @@ export const getInspectMetricsMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof inspectMetrics>>,
-		{ data?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> }
+		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -830,8 +842,7 @@ export type InspectMetricsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof inspectMetrics>>
 >;
 export type InspectMetricsMutationBody =
-	| BodyType<MetricsexplorertypesInspectMetricsRequestDTO>
-	| undefined;
+	BodyType<MetricsexplorertypesInspectMetricsRequestDTO>;
 export type InspectMetricsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -844,16 +855,18 @@ export const useInspectMetrics = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof inspectMetrics>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof inspectMetrics>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesInspectMetricsRequestDTO> },
 	TContext
 > => {
-	return useMutation(getInspectMetricsMutationOptions(options));
+	const mutationOptions = getInspectMetricsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Lightweight endpoint that checks if any non-SigNoz metrics have been ingested, used for onboarding status detection
@@ -923,7 +936,9 @@ export function useGetMetricsOnboardingStatus<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -946,7 +961,7 @@ export const invalidateGetMetricsOnboardingStatus = async (
  * @summary Get metrics statistics
  */
 export const getMetricsStats = (
-	metricsexplorertypesStatsRequestDTO?: BodyType<MetricsexplorertypesStatsRequestDTO>,
+	metricsexplorertypesStatsRequestDTO: BodyType<MetricsexplorertypesStatsRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricsStats200>({
@@ -965,13 +980,13 @@ export const getGetMetricsStatsMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof getMetricsStats>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesStatsRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesStatsRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof getMetricsStats>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesStatsRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesStatsRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['getMetricsStats'];
@@ -985,7 +1000,7 @@ export const getGetMetricsStatsMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof getMetricsStats>>,
-		{ data?: BodyType<MetricsexplorertypesStatsRequestDTO> }
+		{ data: BodyType<MetricsexplorertypesStatsRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -999,8 +1014,7 @@ export type GetMetricsStatsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof getMetricsStats>>
 >;
 export type GetMetricsStatsMutationBody =
-	| BodyType<MetricsexplorertypesStatsRequestDTO>
-	| undefined;
+	BodyType<MetricsexplorertypesStatsRequestDTO>;
 export type GetMetricsStatsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1013,23 +1027,25 @@ export const useGetMetricsStats = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof getMetricsStats>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesStatsRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesStatsRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof getMetricsStats>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesStatsRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesStatsRequestDTO> },
 	TContext
 > => {
-	return useMutation(getGetMetricsStatsMutationOptions(options));
+	const mutationOptions = getGetMetricsStatsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns a treemap visualization showing the proportional distribution of metrics by sample count or time series count
  * @summary Get metrics treemap
  */
 export const getMetricsTreemap = (
-	metricsexplorertypesTreemapRequestDTO?: BodyType<MetricsexplorertypesTreemapRequestDTO>,
+	metricsexplorertypesTreemapRequestDTO: BodyType<MetricsexplorertypesTreemapRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetMetricsTreemap200>({
@@ -1048,13 +1064,13 @@ export const getGetMetricsTreemapMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof getMetricsTreemap>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesTreemapRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesTreemapRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof getMetricsTreemap>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesTreemapRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesTreemapRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['getMetricsTreemap'];
@@ -1068,7 +1084,7 @@ export const getGetMetricsTreemapMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof getMetricsTreemap>>,
-		{ data?: BodyType<MetricsexplorertypesTreemapRequestDTO> }
+		{ data: BodyType<MetricsexplorertypesTreemapRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -1082,8 +1098,7 @@ export type GetMetricsTreemapMutationResult = NonNullable<
 	Awaited<ReturnType<typeof getMetricsTreemap>>
 >;
 export type GetMetricsTreemapMutationBody =
-	| BodyType<MetricsexplorertypesTreemapRequestDTO>
-	| undefined;
+	BodyType<MetricsexplorertypesTreemapRequestDTO>;
 export type GetMetricsTreemapMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1096,14 +1111,16 @@ export const useGetMetricsTreemap = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof getMetricsTreemap>>,
 		TError,
-		{ data?: BodyType<MetricsexplorertypesTreemapRequestDTO> },
+		{ data: BodyType<MetricsexplorertypesTreemapRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof getMetricsTreemap>>,
 	TError,
-	{ data?: BodyType<MetricsexplorertypesTreemapRequestDTO> },
+	{ data: BodyType<MetricsexplorertypesTreemapRequestDTO> },
 	TContext
 > => {
-	return useMutation(getGetMetricsTreemapMutationOptions(options));
+	const mutationOptions = getGetMetricsTreemapMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/orgs/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -93,7 +92,9 @@ export function useGetMyOrganization<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -116,15 +117,13 @@ export const invalidateGetMyOrganization = async (
  * @summary Update my organization
  */
 export const updateMyOrganization = (
-	typesOrganizationDTO?: BodyType<TypesOrganizationDTO>,
-	signal?: AbortSignal,
+	typesOrganizationDTO: BodyType<TypesOrganizationDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/orgs/me`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: typesOrganizationDTO,
-		signal,
 	});
 };
 
@@ -135,13 +134,13 @@ export const getUpdateMyOrganizationMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyOrganization>>,
 		TError,
-		{ data?: BodyType<TypesOrganizationDTO> },
+		{ data: BodyType<TypesOrganizationDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof updateMyOrganization>>,
 	TError,
-	{ data?: BodyType<TypesOrganizationDTO> },
+	{ data: BodyType<TypesOrganizationDTO> },
 	TContext
 > => {
 	const mutationKey = ['updateMyOrganization'];
@@ -155,7 +154,7 @@ export const getUpdateMyOrganizationMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof updateMyOrganization>>,
-		{ data?: BodyType<TypesOrganizationDTO> }
+		{ data: BodyType<TypesOrganizationDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -168,9 +167,7 @@ export const getUpdateMyOrganizationMutationOptions = <
 export type UpdateMyOrganizationMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateMyOrganization>>
 >;
-export type UpdateMyOrganizationMutationBody =
-	| BodyType<TypesOrganizationDTO>
-	| undefined;
+export type UpdateMyOrganizationMutationBody = BodyType<TypesOrganizationDTO>;
 export type UpdateMyOrganizationMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -184,14 +181,16 @@ export const useUpdateMyOrganization = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyOrganization>>,
 		TError,
-		{ data?: BodyType<TypesOrganizationDTO> },
+		{ data: BodyType<TypesOrganizationDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof updateMyOrganization>>,
 	TError,
-	{ data?: BodyType<TypesOrganizationDTO> },
+	{ data: BodyType<TypesOrganizationDTO> },
 	TContext
 > => {
-	return useMutation(getUpdateMyOrganizationMutationOptions(options));
+	const mutationOptions = getUpdateMyOrganizationMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/preferences/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -100,7 +99,9 @@ export function useListOrgPreferences<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -201,7 +202,9 @@ export function useGetOrgPreference<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -226,15 +229,13 @@ export const invalidateGetOrgPreference = async (
  */
 export const updateOrgPreference = (
 	{ name }: UpdateOrgPreferencePathParameters,
-	preferencetypesUpdatablePreferenceDTO?: BodyType<PreferencetypesUpdatablePreferenceDTO>,
-	signal?: AbortSignal,
+	preferencetypesUpdatablePreferenceDTO: BodyType<PreferencetypesUpdatablePreferenceDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/org/preferences/${name}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: preferencetypesUpdatablePreferenceDTO,
-		signal,
 	});
 };
 
@@ -247,7 +248,7 @@ export const getUpdateOrgPreferenceMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateOrgPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		},
 		TContext
 	>;
@@ -256,7 +257,7 @@ export const getUpdateOrgPreferenceMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateOrgPreferencePathParameters;
-		data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+		data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 	},
 	TContext
 > => {
@@ -273,7 +274,7 @@ export const getUpdateOrgPreferenceMutationOptions = <
 		Awaited<ReturnType<typeof updateOrgPreference>>,
 		{
 			pathParams: UpdateOrgPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -288,8 +289,7 @@ export type UpdateOrgPreferenceMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateOrgPreference>>
 >;
 export type UpdateOrgPreferenceMutationBody =
-	| BodyType<PreferencetypesUpdatablePreferenceDTO>
-	| undefined;
+	BodyType<PreferencetypesUpdatablePreferenceDTO>;
 export type UpdateOrgPreferenceMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -305,7 +305,7 @@ export const useUpdateOrgPreference = <
 		TError,
 		{
 			pathParams: UpdateOrgPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		},
 		TContext
 	>;
@@ -314,11 +314,13 @@ export const useUpdateOrgPreference = <
 	TError,
 	{
 		pathParams: UpdateOrgPreferencePathParameters;
-		data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+		data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateOrgPreferenceMutationOptions(options));
+	const mutationOptions = getUpdateOrgPreferenceMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint lists all user preferences
@@ -386,7 +388,9 @@ export function useListUserPreferences<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -487,7 +491,9 @@ export function useGetUserPreference<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -512,15 +518,13 @@ export const invalidateGetUserPreference = async (
  */
 export const updateUserPreference = (
 	{ name }: UpdateUserPreferencePathParameters,
-	preferencetypesUpdatablePreferenceDTO?: BodyType<PreferencetypesUpdatablePreferenceDTO>,
-	signal?: AbortSignal,
+	preferencetypesUpdatablePreferenceDTO: BodyType<PreferencetypesUpdatablePreferenceDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/user/preferences/${name}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: preferencetypesUpdatablePreferenceDTO,
-		signal,
 	});
 };
 
@@ -533,7 +537,7 @@ export const getUpdateUserPreferenceMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateUserPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		},
 		TContext
 	>;
@@ -542,7 +546,7 @@ export const getUpdateUserPreferenceMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateUserPreferencePathParameters;
-		data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+		data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 	},
 	TContext
 > => {
@@ -559,7 +563,7 @@ export const getUpdateUserPreferenceMutationOptions = <
 		Awaited<ReturnType<typeof updateUserPreference>>,
 		{
 			pathParams: UpdateUserPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -574,8 +578,7 @@ export type UpdateUserPreferenceMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateUserPreference>>
 >;
 export type UpdateUserPreferenceMutationBody =
-	| BodyType<PreferencetypesUpdatablePreferenceDTO>
-	| undefined;
+	BodyType<PreferencetypesUpdatablePreferenceDTO>;
 export type UpdateUserPreferenceMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -591,7 +594,7 @@ export const useUpdateUserPreference = <
 		TError,
 		{
 			pathParams: UpdateUserPreferencePathParameters;
-			data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+			data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 		},
 		TContext
 	>;
@@ -600,9 +603,11 @@ export const useUpdateUserPreference = <
 	TError,
 	{
 		pathParams: UpdateUserPreferencePathParameters;
-		data?: BodyType<PreferencetypesUpdatablePreferenceDTO>;
+		data: BodyType<PreferencetypesUpdatablePreferenceDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateUserPreferenceMutationOptions(options));
+	const mutationOptions = getUpdateUserPreferenceMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/querier/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation } from 'react-query';
 import type {
@@ -27,7 +26,7 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  * @summary Query range
  */
 export const queryRangeV5 = (
-	querybuildertypesv5QueryRangeRequestDTO?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
+	querybuildertypesv5QueryRangeRequestDTO: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<QueryRangeV5200>({
@@ -46,13 +45,13 @@ export const getQueryRangeV5MutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof queryRangeV5>>,
 		TError,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof queryRangeV5>>,
 	TError,
-	{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+	{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['queryRangeV5'];
@@ -66,7 +65,7 @@ export const getQueryRangeV5MutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof queryRangeV5>>,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> }
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -80,8 +79,7 @@ export type QueryRangeV5MutationResult = NonNullable<
 	Awaited<ReturnType<typeof queryRangeV5>>
 >;
 export type QueryRangeV5MutationBody =
-	| BodyType<Querybuildertypesv5QueryRangeRequestDTO>
-	| undefined;
+	BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 export type QueryRangeV5MutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -94,23 +92,25 @@ export const useQueryRangeV5 = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof queryRangeV5>>,
 		TError,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof queryRangeV5>>,
 	TError,
-	{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+	{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 	TContext
 > => {
-	return useMutation(getQueryRangeV5MutationOptions(options));
+	const mutationOptions = getQueryRangeV5MutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Replace variables in a query
  * @summary Replace variables
  */
 export const replaceVariables = (
-	querybuildertypesv5QueryRangeRequestDTO?: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
+	querybuildertypesv5QueryRangeRequestDTO: BodyType<Querybuildertypesv5QueryRangeRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<ReplaceVariables200>({
@@ -129,13 +129,13 @@ export const getReplaceVariablesMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof replaceVariables>>,
 		TError,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof replaceVariables>>,
 	TError,
-	{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+	{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['replaceVariables'];
@@ -149,7 +149,7 @@ export const getReplaceVariablesMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof replaceVariables>>,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> }
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -163,8 +163,7 @@ export type ReplaceVariablesMutationResult = NonNullable<
 	Awaited<ReturnType<typeof replaceVariables>>
 >;
 export type ReplaceVariablesMutationBody =
-	| BodyType<Querybuildertypesv5QueryRangeRequestDTO>
-	| undefined;
+	BodyType<Querybuildertypesv5QueryRangeRequestDTO>;
 export type ReplaceVariablesMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -177,14 +176,16 @@ export const useReplaceVariables = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof replaceVariables>>,
 		TError,
-		{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+		{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof replaceVariables>>,
 	TError,
-	{ data?: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
+	{ data: BodyType<Querybuildertypesv5QueryRangeRequestDTO> },
 	TContext
 > => {
-	return useMutation(getReplaceVariablesMutationOptions(options));
+	const mutationOptions = getReplaceVariablesMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/role/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -95,7 +94,9 @@ export function useListRoles<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -118,7 +119,7 @@ export const invalidateListRoles = async (
  * @summary Create role
  */
 export const createRole = (
-	authtypesPostableRoleDTO?: BodyType<AuthtypesPostableRoleDTO>,
+	authtypesPostableRoleDTO: BodyType<AuthtypesPostableRoleDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateRole201>({
@@ -137,13 +138,13 @@ export const getCreateRoleMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRole>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableRoleDTO> },
+		{ data: BodyType<AuthtypesPostableRoleDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createRole>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableRoleDTO> },
+	{ data: BodyType<AuthtypesPostableRoleDTO> },
 	TContext
 > => {
 	const mutationKey = ['createRole'];
@@ -157,7 +158,7 @@ export const getCreateRoleMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createRole>>,
-		{ data?: BodyType<AuthtypesPostableRoleDTO> }
+		{ data: BodyType<AuthtypesPostableRoleDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -170,9 +171,7 @@ export const getCreateRoleMutationOptions = <
 export type CreateRoleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createRole>>
 >;
-export type CreateRoleMutationBody =
-	| BodyType<AuthtypesPostableRoleDTO>
-	| undefined;
+export type CreateRoleMutationBody = BodyType<AuthtypesPostableRoleDTO>;
 export type CreateRoleMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -185,29 +184,27 @@ export const useCreateRole = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRole>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableRoleDTO> },
+		{ data: BodyType<AuthtypesPostableRoleDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createRole>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableRoleDTO> },
+	{ data: BodyType<AuthtypesPostableRoleDTO> },
 	TContext
 > => {
-	return useMutation(getCreateRoleMutationOptions(options));
+	const mutationOptions = getCreateRoleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes a role
  * @summary Delete role
  */
-export const deleteRole = (
-	{ id }: DeleteRolePathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteRole = ({ id }: DeleteRolePathParameters) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -273,7 +270,9 @@ export const useDeleteRole = <
 	{ pathParams: DeleteRolePathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteRoleMutationOptions(options));
+	const mutationOptions = getDeleteRoleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint gets a role
@@ -345,7 +344,9 @@ export function useGetRole<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -370,15 +371,13 @@ export const invalidateGetRole = async (
  */
 export const patchRole = (
 	{ id }: PatchRolePathParameters,
-	authtypesPatchableRoleDTO?: BodyType<AuthtypesPatchableRoleDTO>,
-	signal?: AbortSignal,
+	authtypesPatchableRoleDTO: BodyType<AuthtypesPatchableRoleDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: authtypesPatchableRoleDTO,
-		signal,
 	});
 };
 
@@ -391,7 +390,7 @@ export const getPatchRoleMutationOptions = <
 		TError,
 		{
 			pathParams: PatchRolePathParameters;
-			data?: BodyType<AuthtypesPatchableRoleDTO>;
+			data: BodyType<AuthtypesPatchableRoleDTO>;
 		},
 		TContext
 	>;
@@ -400,7 +399,7 @@ export const getPatchRoleMutationOptions = <
 	TError,
 	{
 		pathParams: PatchRolePathParameters;
-		data?: BodyType<AuthtypesPatchableRoleDTO>;
+		data: BodyType<AuthtypesPatchableRoleDTO>;
 	},
 	TContext
 > => {
@@ -417,7 +416,7 @@ export const getPatchRoleMutationOptions = <
 		Awaited<ReturnType<typeof patchRole>>,
 		{
 			pathParams: PatchRolePathParameters;
-			data?: BodyType<AuthtypesPatchableRoleDTO>;
+			data: BodyType<AuthtypesPatchableRoleDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -431,9 +430,7 @@ export const getPatchRoleMutationOptions = <
 export type PatchRoleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof patchRole>>
 >;
-export type PatchRoleMutationBody =
-	| BodyType<AuthtypesPatchableRoleDTO>
-	| undefined;
+export type PatchRoleMutationBody = BodyType<AuthtypesPatchableRoleDTO>;
 export type PatchRoleMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -448,7 +445,7 @@ export const usePatchRole = <
 		TError,
 		{
 			pathParams: PatchRolePathParameters;
-			data?: BodyType<AuthtypesPatchableRoleDTO>;
+			data: BodyType<AuthtypesPatchableRoleDTO>;
 		},
 		TContext
 	>;
@@ -457,11 +454,13 @@ export const usePatchRole = <
 	TError,
 	{
 		pathParams: PatchRolePathParameters;
-		data?: BodyType<AuthtypesPatchableRoleDTO>;
+		data: BodyType<AuthtypesPatchableRoleDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getPatchRoleMutationOptions(options));
+	const mutationOptions = getPatchRoleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Gets all objects connected to the specified role via a given relation type
@@ -545,7 +544,9 @@ export function useGetObjects<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -570,15 +571,13 @@ export const invalidateGetObjects = async (
  */
 export const patchObjects = (
 	{ id, relation }: PatchObjectsPathParameters,
-	coretypesPatchableObjectsDTO?: BodyType<CoretypesPatchableObjectsDTO>,
-	signal?: AbortSignal,
+	coretypesPatchableObjectsDTO: BodyType<CoretypesPatchableObjectsDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}/relations/${relation}/objects`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: coretypesPatchableObjectsDTO,
-		signal,
 	});
 };
 
@@ -591,7 +590,7 @@ export const getPatchObjectsMutationOptions = <
 		TError,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data?: BodyType<CoretypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		},
 		TContext
 	>;
@@ -600,7 +599,7 @@ export const getPatchObjectsMutationOptions = <
 	TError,
 	{
 		pathParams: PatchObjectsPathParameters;
-		data?: BodyType<CoretypesPatchableObjectsDTO>;
+		data: BodyType<CoretypesPatchableObjectsDTO>;
 	},
 	TContext
 > => {
@@ -617,7 +616,7 @@ export const getPatchObjectsMutationOptions = <
 		Awaited<ReturnType<typeof patchObjects>>,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data?: BodyType<CoretypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -631,9 +630,7 @@ export const getPatchObjectsMutationOptions = <
 export type PatchObjectsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof patchObjects>>
 >;
-export type PatchObjectsMutationBody =
-	| BodyType<CoretypesPatchableObjectsDTO>
-	| undefined;
+export type PatchObjectsMutationBody = BodyType<CoretypesPatchableObjectsDTO>;
 export type PatchObjectsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -648,7 +645,7 @@ export const usePatchObjects = <
 		TError,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data?: BodyType<CoretypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		},
 		TContext
 	>;
@@ -657,9 +654,11 @@ export const usePatchObjects = <
 	TError,
 	{
 		pathParams: PatchObjectsPathParameters;
-		data?: BodyType<CoretypesPatchableObjectsDTO>;
+		data: BodyType<CoretypesPatchableObjectsDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getPatchObjectsMutationOptions(options));
+	const mutationOptions = getPatchObjectsMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/routepolicies/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -99,7 +98,9 @@ export function useGetAllRoutePolicies<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -122,7 +123,7 @@ export const invalidateGetAllRoutePolicies = async (
  * @summary Create route policy
  */
 export const createRoutePolicy = (
-	alertmanagertypesPostableRoutePolicyDTO?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
+	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateRoutePolicy201>({
@@ -141,13 +142,13 @@ export const getCreateRoutePolicyMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRoutePolicy>>,
 		TError,
-		{ data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createRoutePolicy>>,
 	TError,
-	{ data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
 	TContext
 > => {
 	const mutationKey = ['createRoutePolicy'];
@@ -161,7 +162,7 @@ export const getCreateRoutePolicyMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createRoutePolicy>>,
-		{ data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO> }
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -175,8 +176,7 @@ export type CreateRoutePolicyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createRoutePolicy>>
 >;
 export type CreateRoutePolicyMutationBody =
-	| BodyType<AlertmanagertypesPostableRoutePolicyDTO>
-	| undefined;
+	BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 export type CreateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -189,29 +189,29 @@ export const useCreateRoutePolicy = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRoutePolicy>>,
 		TError,
-		{ data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+		{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createRoutePolicy>>,
 	TError,
-	{ data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
+	{ data: BodyType<AlertmanagertypesPostableRoutePolicyDTO> },
 	TContext
 > => {
-	return useMutation(getCreateRoutePolicyMutationOptions(options));
+	const mutationOptions = getCreateRoutePolicyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes a route policy by ID
  * @summary Delete route policy
  */
-export const deleteRoutePolicyByID = (
-	{ id }: DeleteRoutePolicyByIDPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteRoutePolicyByID = ({
+	id,
+}: DeleteRoutePolicyByIDPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/route_policies/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -278,7 +278,9 @@ export const useDeleteRoutePolicyByID = <
 	{ pathParams: DeleteRoutePolicyByIDPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteRoutePolicyByIDMutationOptions(options));
+	const mutationOptions = getDeleteRoutePolicyByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns a route policy by ID
@@ -363,7 +365,9 @@ export function useGetRoutePolicyByID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -388,15 +392,13 @@ export const invalidateGetRoutePolicyByID = async (
  */
 export const updateRoutePolicy = (
 	{ id }: UpdateRoutePolicyPathParameters,
-	alertmanagertypesPostableRoutePolicyDTO?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
-	signal?: AbortSignal,
+	alertmanagertypesPostableRoutePolicyDTO: BodyType<AlertmanagertypesPostableRoutePolicyDTO>,
 ) => {
 	return GeneratedAPIInstance<UpdateRoutePolicy200>({
 		url: `/api/v1/route_policies/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: alertmanagertypesPostableRoutePolicyDTO,
-		signal,
 	});
 };
 
@@ -409,7 +411,7 @@ export const getUpdateRoutePolicyMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateRoutePolicyPathParameters;
-			data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 		},
 		TContext
 	>;
@@ -418,7 +420,7 @@ export const getUpdateRoutePolicyMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateRoutePolicyPathParameters;
-		data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 	},
 	TContext
 > => {
@@ -435,7 +437,7 @@ export const getUpdateRoutePolicyMutationOptions = <
 		Awaited<ReturnType<typeof updateRoutePolicy>>,
 		{
 			pathParams: UpdateRoutePolicyPathParameters;
-			data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -450,8 +452,7 @@ export type UpdateRoutePolicyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateRoutePolicy>>
 >;
 export type UpdateRoutePolicyMutationBody =
-	| BodyType<AlertmanagertypesPostableRoutePolicyDTO>
-	| undefined;
+	BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 export type UpdateRoutePolicyMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -466,7 +467,7 @@ export const useUpdateRoutePolicy = <
 		TError,
 		{
 			pathParams: UpdateRoutePolicyPathParameters;
-			data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+			data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 		},
 		TContext
 	>;
@@ -475,9 +476,11 @@ export const useUpdateRoutePolicy = <
 	TError,
 	{
 		pathParams: UpdateRoutePolicyPathParameters;
-		data?: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
+		data: BodyType<AlertmanagertypesPostableRoutePolicyDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateRoutePolicyMutationOptions(options));
+	const mutationOptions = getUpdateRoutePolicyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/rules/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -111,7 +110,9 @@ export function useListRules<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -134,7 +135,7 @@ export const invalidateListRules = async (
  * @summary Create alert rule
  */
 export const createRule = (
-	ruletypesPostableRuleDTO?: BodyType<RuletypesPostableRuleDTO>,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateRule201>({
@@ -153,13 +154,13 @@ export const getCreateRuleMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostableRuleDTO> },
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createRule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostableRuleDTO> },
+	{ data: BodyType<RuletypesPostableRuleDTO> },
 	TContext
 > => {
 	const mutationKey = ['createRule'];
@@ -173,7 +174,7 @@ export const getCreateRuleMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createRule>>,
-		{ data?: BodyType<RuletypesPostableRuleDTO> }
+		{ data: BodyType<RuletypesPostableRuleDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -186,9 +187,7 @@ export const getCreateRuleMutationOptions = <
 export type CreateRuleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createRule>>
 >;
-export type CreateRuleMutationBody =
-	| BodyType<RuletypesPostableRuleDTO>
-	| undefined;
+export type CreateRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
 export type CreateRuleMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -201,29 +200,27 @@ export const useCreateRule = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createRule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostableRuleDTO> },
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createRule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostableRuleDTO> },
+	{ data: BodyType<RuletypesPostableRuleDTO> },
 	TContext
 > => {
-	return useMutation(getCreateRuleMutationOptions(options));
+	const mutationOptions = getCreateRuleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes an alert rule by ID
  * @summary Delete alert rule
  */
-export const deleteRuleByID = (
-	{ id }: DeleteRuleByIDPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteRuleByID = ({ id }: DeleteRuleByIDPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/rules/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -289,7 +286,9 @@ export const useDeleteRuleByID = <
 	{ pathParams: DeleteRuleByIDPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteRuleByIDMutationOptions(options));
+	const mutationOptions = getDeleteRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns an alert rule by ID
@@ -371,7 +370,9 @@ export function useGetRuleByID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -396,15 +397,13 @@ export const invalidateGetRuleByID = async (
  */
 export const patchRuleByID = (
 	{ id }: PatchRuleByIDPathParameters,
-	ruletypesPostableRuleDTO?: BodyType<RuletypesPostableRuleDTO>,
-	signal?: AbortSignal,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
 ) => {
 	return GeneratedAPIInstance<PatchRuleByID200>({
 		url: `/api/v2/rules/${id}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: ruletypesPostableRuleDTO,
-		signal,
 	});
 };
 
@@ -417,7 +416,7 @@ export const getPatchRuleByIDMutationOptions = <
 		TError,
 		{
 			pathParams: PatchRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		},
 		TContext
 	>;
@@ -426,7 +425,7 @@ export const getPatchRuleByIDMutationOptions = <
 	TError,
 	{
 		pathParams: PatchRuleByIDPathParameters;
-		data?: BodyType<RuletypesPostableRuleDTO>;
+		data: BodyType<RuletypesPostableRuleDTO>;
 	},
 	TContext
 > => {
@@ -443,7 +442,7 @@ export const getPatchRuleByIDMutationOptions = <
 		Awaited<ReturnType<typeof patchRuleByID>>,
 		{
 			pathParams: PatchRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -457,9 +456,7 @@ export const getPatchRuleByIDMutationOptions = <
 export type PatchRuleByIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof patchRuleByID>>
 >;
-export type PatchRuleByIDMutationBody =
-	| BodyType<RuletypesPostableRuleDTO>
-	| undefined;
+export type PatchRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
 export type PatchRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -474,7 +471,7 @@ export const usePatchRuleByID = <
 		TError,
 		{
 			pathParams: PatchRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		},
 		TContext
 	>;
@@ -483,11 +480,13 @@ export const usePatchRuleByID = <
 	TError,
 	{
 		pathParams: PatchRuleByIDPathParameters;
-		data?: BodyType<RuletypesPostableRuleDTO>;
+		data: BodyType<RuletypesPostableRuleDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getPatchRuleByIDMutationOptions(options));
+	const mutationOptions = getPatchRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates an alert rule by ID
@@ -495,15 +494,13 @@ export const usePatchRuleByID = <
  */
 export const updateRuleByID = (
 	{ id }: UpdateRuleByIDPathParameters,
-	ruletypesPostableRuleDTO?: BodyType<RuletypesPostableRuleDTO>,
-	signal?: AbortSignal,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/rules/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: ruletypesPostableRuleDTO,
-		signal,
 	});
 };
 
@@ -516,7 +513,7 @@ export const getUpdateRuleByIDMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		},
 		TContext
 	>;
@@ -525,7 +522,7 @@ export const getUpdateRuleByIDMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateRuleByIDPathParameters;
-		data?: BodyType<RuletypesPostableRuleDTO>;
+		data: BodyType<RuletypesPostableRuleDTO>;
 	},
 	TContext
 > => {
@@ -542,7 +539,7 @@ export const getUpdateRuleByIDMutationOptions = <
 		Awaited<ReturnType<typeof updateRuleByID>>,
 		{
 			pathParams: UpdateRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -556,9 +553,7 @@ export const getUpdateRuleByIDMutationOptions = <
 export type UpdateRuleByIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateRuleByID>>
 >;
-export type UpdateRuleByIDMutationBody =
-	| BodyType<RuletypesPostableRuleDTO>
-	| undefined;
+export type UpdateRuleByIDMutationBody = BodyType<RuletypesPostableRuleDTO>;
 export type UpdateRuleByIDMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -573,7 +568,7 @@ export const useUpdateRuleByID = <
 		TError,
 		{
 			pathParams: UpdateRuleByIDPathParameters;
-			data?: BodyType<RuletypesPostableRuleDTO>;
+			data: BodyType<RuletypesPostableRuleDTO>;
 		},
 		TContext
 	>;
@@ -582,11 +577,13 @@ export const useUpdateRuleByID = <
 	TError,
 	{
 		pathParams: UpdateRuleByIDPathParameters;
-		data?: BodyType<RuletypesPostableRuleDTO>;
+		data: BodyType<RuletypesPostableRuleDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateRuleByIDMutationOptions(options));
+	const mutationOptions = getUpdateRuleByIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns distinct label keys from rule history entries for the selected range.
@@ -684,7 +681,9 @@ export function useGetRuleHistoryFilterKeys<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -801,7 +800,9 @@ export function useGetRuleHistoryFilterValues<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -918,7 +919,9 @@ export function useGetRuleHistoryOverallStatus<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1033,7 +1036,9 @@ export function useGetRuleHistoryStats<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1149,7 +1154,9 @@ export function useGetRuleHistoryTimeline<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1266,7 +1273,9 @@ export function useGetRuleHistoryTopContributors<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1291,7 +1300,7 @@ export const invalidateGetRuleHistoryTopContributors = async (
  * @summary Test alert rule
  */
 export const testRule = (
-	ruletypesPostableRuleDTO?: BodyType<RuletypesPostableRuleDTO>,
+	ruletypesPostableRuleDTO: BodyType<RuletypesPostableRuleDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<TestRule200>({
@@ -1310,13 +1319,13 @@ export const getTestRuleMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testRule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostableRuleDTO> },
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof testRule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostableRuleDTO> },
+	{ data: BodyType<RuletypesPostableRuleDTO> },
 	TContext
 > => {
 	const mutationKey = ['testRule'];
@@ -1330,7 +1339,7 @@ export const getTestRuleMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof testRule>>,
-		{ data?: BodyType<RuletypesPostableRuleDTO> }
+		{ data: BodyType<RuletypesPostableRuleDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -1343,9 +1352,7 @@ export const getTestRuleMutationOptions = <
 export type TestRuleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof testRule>>
 >;
-export type TestRuleMutationBody =
-	| BodyType<RuletypesPostableRuleDTO>
-	| undefined;
+export type TestRuleMutationBody = BodyType<RuletypesPostableRuleDTO>;
 export type TestRuleMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1358,14 +1365,16 @@ export const useTestRule = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof testRule>>,
 		TError,
-		{ data?: BodyType<RuletypesPostableRuleDTO> },
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof testRule>>,
 	TError,
-	{ data?: BodyType<RuletypesPostableRuleDTO> },
+	{ data: BodyType<RuletypesPostableRuleDTO> },
 	TContext
 > => {
-	return useMutation(getTestRuleMutationOptions(options));
+	const mutationOptions = getTestRuleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/serviceaccount/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -113,7 +112,9 @@ export function useListServiceAccounts<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -136,7 +137,7 @@ export const invalidateListServiceAccounts = async (
  * @summary Create service account
  */
 export const createServiceAccount = (
-	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
+	serviceaccounttypesPostableServiceAccountDTO: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateServiceAccount201>({
@@ -155,13 +156,13 @@ export const getCreateServiceAccountMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createServiceAccount>>,
 		TError,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createServiceAccount>>,
 	TError,
-	{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 	TContext
 > => {
 	const mutationKey = ['createServiceAccount'];
@@ -175,7 +176,7 @@ export const getCreateServiceAccountMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createServiceAccount>>,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> }
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -189,8 +190,7 @@ export type CreateServiceAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createServiceAccount>>
 >;
 export type CreateServiceAccountMutationBody =
-	| BodyType<ServiceaccounttypesPostableServiceAccountDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 export type CreateServiceAccountMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -204,29 +204,29 @@ export const useCreateServiceAccount = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createServiceAccount>>,
 		TError,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createServiceAccount>>,
 	TError,
-	{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 	TContext
 > => {
-	return useMutation(getCreateServiceAccountMutationOptions(options));
+	const mutationOptions = getCreateServiceAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes an existing service account
  * @summary Deletes a service account
  */
-export const deleteServiceAccount = (
-	{ id }: DeleteServiceAccountPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteServiceAccount = ({
+	id,
+}: DeleteServiceAccountPathParameters) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -293,7 +293,9 @@ export const useDeleteServiceAccount = <
 	{ pathParams: DeleteServiceAccountPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteServiceAccountMutationOptions(options));
+	const mutationOptions = getDeleteServiceAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint gets an existing service account
@@ -378,7 +380,9 @@ export function useGetServiceAccount<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -403,15 +407,13 @@ export const invalidateGetServiceAccount = async (
  */
 export const updateServiceAccount = (
 	{ id }: UpdateServiceAccountPathParameters,
-	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
-	signal?: AbortSignal,
+	serviceaccounttypesPostableServiceAccountDTO: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: serviceaccounttypesPostableServiceAccountDTO,
-		signal,
 	});
 };
 
@@ -424,7 +426,7 @@ export const getUpdateServiceAccountMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 		},
 		TContext
 	>;
@@ -433,7 +435,7 @@ export const getUpdateServiceAccountMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountPathParameters;
-		data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+		data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 	},
 	TContext
 > => {
@@ -450,7 +452,7 @@ export const getUpdateServiceAccountMutationOptions = <
 		Awaited<ReturnType<typeof updateServiceAccount>>,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -465,8 +467,7 @@ export type UpdateServiceAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateServiceAccount>>
 >;
 export type UpdateServiceAccountMutationBody =
-	| BodyType<ServiceaccounttypesPostableServiceAccountDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 export type UpdateServiceAccountMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -482,7 +483,7 @@ export const useUpdateServiceAccount = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 		},
 		TContext
 	>;
@@ -491,11 +492,13 @@ export const useUpdateServiceAccount = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountPathParameters;
-		data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
+		data: BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateServiceAccountMutationOptions(options));
+	const mutationOptions = getUpdateServiceAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint lists the service account keys
@@ -581,7 +584,9 @@ export function useListServiceAccountKeys<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -606,7 +611,7 @@ export const invalidateListServiceAccountKeys = async (
  */
 export const createServiceAccountKey = (
 	{ id }: CreateServiceAccountKeyPathParameters,
-	serviceaccounttypesPostableFactorAPIKeyDTO?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>,
+	serviceaccounttypesPostableFactorAPIKeyDTO: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateServiceAccountKey201>({
@@ -627,7 +632,7 @@ export const getCreateServiceAccountKeyMutationOptions = <
 		TError,
 		{
 			pathParams: CreateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 		},
 		TContext
 	>;
@@ -636,7 +641,7 @@ export const getCreateServiceAccountKeyMutationOptions = <
 	TError,
 	{
 		pathParams: CreateServiceAccountKeyPathParameters;
-		data?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
+		data: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 	},
 	TContext
 > => {
@@ -653,7 +658,7 @@ export const getCreateServiceAccountKeyMutationOptions = <
 		Awaited<ReturnType<typeof createServiceAccountKey>>,
 		{
 			pathParams: CreateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -668,8 +673,7 @@ export type CreateServiceAccountKeyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createServiceAccountKey>>
 >;
 export type CreateServiceAccountKeyMutationBody =
-	| BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 export type CreateServiceAccountKeyMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -685,7 +689,7 @@ export const useCreateServiceAccountKey = <
 		TError,
 		{
 			pathParams: CreateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 		},
 		TContext
 	>;
@@ -694,24 +698,25 @@ export const useCreateServiceAccountKey = <
 	TError,
 	{
 		pathParams: CreateServiceAccountKeyPathParameters;
-		data?: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
+		data: BodyType<ServiceaccounttypesPostableFactorAPIKeyDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreateServiceAccountKeyMutationOptions(options));
+	const mutationOptions = getCreateServiceAccountKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint revokes an existing service account key
  * @summary Revoke a service account key
  */
-export const revokeServiceAccountKey = (
-	{ id, fid }: RevokeServiceAccountKeyPathParameters,
-	signal?: AbortSignal,
-) => {
+export const revokeServiceAccountKey = ({
+	id,
+	fid,
+}: RevokeServiceAccountKeyPathParameters) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -778,7 +783,9 @@ export const useRevokeServiceAccountKey = <
 	{ pathParams: RevokeServiceAccountKeyPathParameters },
 	TContext
 > => {
-	return useMutation(getRevokeServiceAccountKeyMutationOptions(options));
+	const mutationOptions = getRevokeServiceAccountKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates an existing service account key
@@ -786,15 +793,13 @@ export const useRevokeServiceAccountKey = <
  */
 export const updateServiceAccountKey = (
 	{ id, fid }: UpdateServiceAccountKeyPathParameters,
-	serviceaccounttypesUpdatableFactorAPIKeyDTO?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>,
-	signal?: AbortSignal,
+	serviceaccounttypesUpdatableFactorAPIKeyDTO: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: serviceaccounttypesUpdatableFactorAPIKeyDTO,
-		signal,
 	});
 };
 
@@ -807,7 +812,7 @@ export const getUpdateServiceAccountKeyMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 		},
 		TContext
 	>;
@@ -816,7 +821,7 @@ export const getUpdateServiceAccountKeyMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountKeyPathParameters;
-		data?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
+		data: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 	},
 	TContext
 > => {
@@ -833,7 +838,7 @@ export const getUpdateServiceAccountKeyMutationOptions = <
 		Awaited<ReturnType<typeof updateServiceAccountKey>>,
 		{
 			pathParams: UpdateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -848,8 +853,7 @@ export type UpdateServiceAccountKeyMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateServiceAccountKey>>
 >;
 export type UpdateServiceAccountKeyMutationBody =
-	| BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 export type UpdateServiceAccountKeyMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -865,7 +869,7 @@ export const useUpdateServiceAccountKey = <
 		TError,
 		{
 			pathParams: UpdateServiceAccountKeyPathParameters;
-			data?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
+			data: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 		},
 		TContext
 	>;
@@ -874,11 +878,13 @@ export const useUpdateServiceAccountKey = <
 	TError,
 	{
 		pathParams: UpdateServiceAccountKeyPathParameters;
-		data?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
+		data: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateServiceAccountKeyMutationOptions(options));
+	const mutationOptions = getUpdateServiceAccountKeyMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint gets all the roles for the existing service account
@@ -964,7 +970,9 @@ export function useGetServiceAccountRoles<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -989,7 +997,7 @@ export const invalidateGetServiceAccountRoles = async (
  */
 export const createServiceAccountRole = (
 	{ id }: CreateServiceAccountRolePathParameters,
-	serviceaccounttypesPostableServiceAccountRoleDTO?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>,
+	serviceaccounttypesPostableServiceAccountRoleDTO: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateServiceAccountRole201>({
@@ -1010,7 +1018,7 @@ export const getCreateServiceAccountRoleMutationOptions = <
 		TError,
 		{
 			pathParams: CreateServiceAccountRolePathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 		},
 		TContext
 	>;
@@ -1019,7 +1027,7 @@ export const getCreateServiceAccountRoleMutationOptions = <
 	TError,
 	{
 		pathParams: CreateServiceAccountRolePathParameters;
-		data?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+		data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 	},
 	TContext
 > => {
@@ -1036,7 +1044,7 @@ export const getCreateServiceAccountRoleMutationOptions = <
 		Awaited<ReturnType<typeof createServiceAccountRole>>,
 		{
 			pathParams: CreateServiceAccountRolePathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -1051,8 +1059,7 @@ export type CreateServiceAccountRoleMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createServiceAccountRole>>
 >;
 export type CreateServiceAccountRoleMutationBody =
-	| BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 export type CreateServiceAccountRoleMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -1068,7 +1075,7 @@ export const useCreateServiceAccountRole = <
 		TError,
 		{
 			pathParams: CreateServiceAccountRolePathParameters;
-			data?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+			data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 		},
 		TContext
 	>;
@@ -1077,24 +1084,25 @@ export const useCreateServiceAccountRole = <
 	TError,
 	{
 		pathParams: CreateServiceAccountRolePathParameters;
-		data?: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
+		data: BodyType<ServiceaccounttypesPostableServiceAccountRoleDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreateServiceAccountRoleMutationOptions(options));
+	const mutationOptions = getCreateServiceAccountRoleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint revokes a role from service account
  * @summary Delete service account role
  */
-export const deleteServiceAccountRole = (
-	{ id, rid }: DeleteServiceAccountRolePathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteServiceAccountRole = ({
+	id,
+	rid,
+}: DeleteServiceAccountRolePathParameters) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/roles/${rid}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -1161,7 +1169,9 @@ export const useDeleteServiceAccountRole = <
 	{ pathParams: DeleteServiceAccountRolePathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteServiceAccountRoleMutationOptions(options));
+	const mutationOptions = getDeleteServiceAccountRoleMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint gets my service account
@@ -1229,7 +1239,9 @@ export function useGetMyServiceAccount<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1252,15 +1264,13 @@ export const invalidateGetMyServiceAccount = async (
  * @summary Updates my service account
  */
 export const updateMyServiceAccount = (
-	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
-	signal?: AbortSignal,
+	serviceaccounttypesPostableServiceAccountDTO: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/me`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: serviceaccounttypesPostableServiceAccountDTO,
-		signal,
 	});
 };
 
@@ -1271,13 +1281,13 @@ export const getUpdateMyServiceAccountMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyServiceAccount>>,
 		TError,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof updateMyServiceAccount>>,
 	TError,
-	{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 	TContext
 > => {
 	const mutationKey = ['updateMyServiceAccount'];
@@ -1291,7 +1301,7 @@ export const getUpdateMyServiceAccountMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof updateMyServiceAccount>>,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> }
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -1305,8 +1315,7 @@ export type UpdateMyServiceAccountMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateMyServiceAccount>>
 >;
 export type UpdateMyServiceAccountMutationBody =
-	| BodyType<ServiceaccounttypesPostableServiceAccountDTO>
-	| undefined;
+	BodyType<ServiceaccounttypesPostableServiceAccountDTO>;
 export type UpdateMyServiceAccountMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -1320,14 +1329,16 @@ export const useUpdateMyServiceAccount = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyServiceAccount>>,
 		TError,
-		{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+		{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof updateMyServiceAccount>>,
 	TError,
-	{ data?: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
+	{ data: BodyType<ServiceaccounttypesPostableServiceAccountDTO> },
 	TContext
 > => {
-	return useMutation(getUpdateMyServiceAccountMutationOptions(options));
+	const mutationOptions = getUpdateMyServiceAccountMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/sessions/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -104,7 +103,9 @@ export function useCreateSessionByGoogleCallback<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -191,7 +192,9 @@ export function useCreateSessionByOIDCCallback<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -214,18 +217,18 @@ export const invalidateCreateSessionByOIDCCallback = async (
  * @summary Create session by saml callback
  */
 export const createSessionBySAMLCallback = (
-	createSessionBySAMLCallbackBody?: BodyType<CreateSessionBySAMLCallbackBody>,
+	createSessionBySAMLCallbackBody: BodyType<CreateSessionBySAMLCallbackBody>,
 	params?: CreateSessionBySAMLCallbackParams,
 	signal?: AbortSignal,
 ) => {
 	const formUrlEncoded = new URLSearchParams();
-	if (createSessionBySAMLCallbackBody?.RelayState !== undefined) {
+	if (createSessionBySAMLCallbackBody.RelayState !== undefined) {
 		formUrlEncoded.append(
 			`RelayState`,
 			createSessionBySAMLCallbackBody.RelayState,
 		);
 	}
-	if (createSessionBySAMLCallbackBody?.SAMLResponse !== undefined) {
+	if (createSessionBySAMLCallbackBody.SAMLResponse !== undefined) {
 		formUrlEncoded.append(
 			`SAMLResponse`,
 			createSessionBySAMLCallbackBody.SAMLResponse,
@@ -250,7 +253,7 @@ export const getCreateSessionBySAMLCallbackMutationOptions = <
 		Awaited<ReturnType<typeof createSessionBySAMLCallback>>,
 		TError,
 		{
-			data?: BodyType<CreateSessionBySAMLCallbackBody>;
+			data: BodyType<CreateSessionBySAMLCallbackBody>;
 			params?: CreateSessionBySAMLCallbackParams;
 		},
 		TContext
@@ -259,7 +262,7 @@ export const getCreateSessionBySAMLCallbackMutationOptions = <
 	Awaited<ReturnType<typeof createSessionBySAMLCallback>>,
 	TError,
 	{
-		data?: BodyType<CreateSessionBySAMLCallbackBody>;
+		data: BodyType<CreateSessionBySAMLCallbackBody>;
 		params?: CreateSessionBySAMLCallbackParams;
 	},
 	TContext
@@ -276,7 +279,7 @@ export const getCreateSessionBySAMLCallbackMutationOptions = <
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createSessionBySAMLCallback>>,
 		{
-			data?: BodyType<CreateSessionBySAMLCallbackBody>;
+			data: BodyType<CreateSessionBySAMLCallbackBody>;
 			params?: CreateSessionBySAMLCallbackParams;
 		}
 	> = (props) => {
@@ -292,8 +295,7 @@ export type CreateSessionBySAMLCallbackMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createSessionBySAMLCallback>>
 >;
 export type CreateSessionBySAMLCallbackMutationBody =
-	| BodyType<CreateSessionBySAMLCallbackBody>
-	| undefined;
+	BodyType<CreateSessionBySAMLCallbackBody>;
 export type CreateSessionBySAMLCallbackMutationError = ErrorType<
 	CreateSessionBySAMLCallback303 | RenderErrorResponseDTO
 >;
@@ -309,7 +311,7 @@ export const useCreateSessionBySAMLCallback = <
 		Awaited<ReturnType<typeof createSessionBySAMLCallback>>,
 		TError,
 		{
-			data?: BodyType<CreateSessionBySAMLCallbackBody>;
+			data: BodyType<CreateSessionBySAMLCallbackBody>;
 			params?: CreateSessionBySAMLCallbackParams;
 		},
 		TContext
@@ -318,22 +320,23 @@ export const useCreateSessionBySAMLCallback = <
 	Awaited<ReturnType<typeof createSessionBySAMLCallback>>,
 	TError,
 	{
-		data?: BodyType<CreateSessionBySAMLCallbackBody>;
+		data: BodyType<CreateSessionBySAMLCallbackBody>;
 		params?: CreateSessionBySAMLCallbackParams;
 	},
 	TContext
 > => {
-	return useMutation(getCreateSessionBySAMLCallbackMutationOptions(options));
+	const mutationOptions = getCreateSessionBySAMLCallbackMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint deletes the session
  * @summary Delete session
  */
-export const deleteSession = (signal?: AbortSignal) => {
+export const deleteSession = () => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/sessions`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -397,7 +400,9 @@ export const useDeleteSession = <
 	void,
 	TContext
 > => {
-	return useMutation(getDeleteSessionMutationOptions(options));
+	const mutationOptions = getDeleteSessionMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the context for the session
@@ -465,7 +470,9 @@ export function useGetSessionContext<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -488,7 +495,7 @@ export const invalidateGetSessionContext = async (
  * @summary Create session by email and password
  */
 export const createSessionByEmailPassword = (
-	authtypesPostableEmailPasswordSessionDTO?: BodyType<AuthtypesPostableEmailPasswordSessionDTO>,
+	authtypesPostableEmailPasswordSessionDTO: BodyType<AuthtypesPostableEmailPasswordSessionDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateSessionByEmailPassword200>({
@@ -507,13 +514,13 @@ export const getCreateSessionByEmailPasswordMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createSessionByEmailPassword>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
+		{ data: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createSessionByEmailPassword>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
+	{ data: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
 	TContext
 > => {
 	const mutationKey = ['createSessionByEmailPassword'];
@@ -527,7 +534,7 @@ export const getCreateSessionByEmailPasswordMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createSessionByEmailPassword>>,
-		{ data?: BodyType<AuthtypesPostableEmailPasswordSessionDTO> }
+		{ data: BodyType<AuthtypesPostableEmailPasswordSessionDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -541,8 +548,7 @@ export type CreateSessionByEmailPasswordMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createSessionByEmailPassword>>
 >;
 export type CreateSessionByEmailPasswordMutationBody =
-	| BodyType<AuthtypesPostableEmailPasswordSessionDTO>
-	| undefined;
+	BodyType<AuthtypesPostableEmailPasswordSessionDTO>;
 export type CreateSessionByEmailPasswordMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -556,23 +562,26 @@ export const useCreateSessionByEmailPassword = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createSessionByEmailPassword>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
+		{ data: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createSessionByEmailPassword>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
+	{ data: BodyType<AuthtypesPostableEmailPasswordSessionDTO> },
 	TContext
 > => {
-	return useMutation(getCreateSessionByEmailPasswordMutationOptions(options));
+	const mutationOptions =
+		getCreateSessionByEmailPasswordMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint rotates the session
  * @summary Rotate session
  */
 export const rotateSession = (
-	authtypesPostableRotateTokenDTO?: BodyType<AuthtypesPostableRotateTokenDTO>,
+	authtypesPostableRotateTokenDTO: BodyType<AuthtypesPostableRotateTokenDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<RotateSession200>({
@@ -591,13 +600,13 @@ export const getRotateSessionMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof rotateSession>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableRotateTokenDTO> },
+		{ data: BodyType<AuthtypesPostableRotateTokenDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof rotateSession>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableRotateTokenDTO> },
+	{ data: BodyType<AuthtypesPostableRotateTokenDTO> },
 	TContext
 > => {
 	const mutationKey = ['rotateSession'];
@@ -611,7 +620,7 @@ export const getRotateSessionMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof rotateSession>>,
-		{ data?: BodyType<AuthtypesPostableRotateTokenDTO> }
+		{ data: BodyType<AuthtypesPostableRotateTokenDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -625,8 +634,7 @@ export type RotateSessionMutationResult = NonNullable<
 	Awaited<ReturnType<typeof rotateSession>>
 >;
 export type RotateSessionMutationBody =
-	| BodyType<AuthtypesPostableRotateTokenDTO>
-	| undefined;
+	BodyType<AuthtypesPostableRotateTokenDTO>;
 export type RotateSessionMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -639,14 +647,16 @@ export const useRotateSession = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof rotateSession>>,
 		TError,
-		{ data?: BodyType<AuthtypesPostableRotateTokenDTO> },
+		{ data: BodyType<AuthtypesPostableRotateTokenDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof rotateSession>>,
 	TError,
-	{ data?: BodyType<AuthtypesPostableRotateTokenDTO> },
+	{ data: BodyType<AuthtypesPostableRotateTokenDTO> },
 	TContext
 > => {
-	return useMutation(getRotateSessionMutationOptions(options));
+	const mutationOptions = getRotateSessionMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/spanmapper/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -119,7 +118,9 @@ export function useListSpanMapperGroups<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -143,7 +144,7 @@ export const invalidateListSpanMapperGroups = async (
  * @summary Create a span attribute mapping group
  */
 export const createSpanMapperGroup = (
-	spantypesPostableSpanMapperGroupDTO?: BodyType<SpantypesPostableSpanMapperGroupDTO>,
+	spantypesPostableSpanMapperGroupDTO: BodyType<SpantypesPostableSpanMapperGroupDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateSpanMapperGroup201>({
@@ -162,13 +163,13 @@ export const getCreateSpanMapperGroupMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createSpanMapperGroup>>,
 		TError,
-		{ data?: BodyType<SpantypesPostableSpanMapperGroupDTO> },
+		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createSpanMapperGroup>>,
 	TError,
-	{ data?: BodyType<SpantypesPostableSpanMapperGroupDTO> },
+	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
 	TContext
 > => {
 	const mutationKey = ['createSpanMapperGroup'];
@@ -182,7 +183,7 @@ export const getCreateSpanMapperGroupMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createSpanMapperGroup>>,
-		{ data?: BodyType<SpantypesPostableSpanMapperGroupDTO> }
+		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -196,8 +197,7 @@ export type CreateSpanMapperGroupMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createSpanMapperGroup>>
 >;
 export type CreateSpanMapperGroupMutationBody =
-	| BodyType<SpantypesPostableSpanMapperGroupDTO>
-	| undefined;
+	BodyType<SpantypesPostableSpanMapperGroupDTO>;
 export type CreateSpanMapperGroupMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -211,29 +211,29 @@ export const useCreateSpanMapperGroup = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createSpanMapperGroup>>,
 		TError,
-		{ data?: BodyType<SpantypesPostableSpanMapperGroupDTO> },
+		{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createSpanMapperGroup>>,
 	TError,
-	{ data?: BodyType<SpantypesPostableSpanMapperGroupDTO> },
+	{ data: BodyType<SpantypesPostableSpanMapperGroupDTO> },
 	TContext
 > => {
-	return useMutation(getCreateSpanMapperGroupMutationOptions(options));
+	const mutationOptions = getCreateSpanMapperGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Hard-deletes a mapping group and cascades to all its mappers.
  * @summary Delete a span attribute mapping group
  */
-export const deleteSpanMapperGroup = (
-	{ groupId }: DeleteSpanMapperGroupPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteSpanMapperGroup = ({
+	groupId,
+}: DeleteSpanMapperGroupPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/span_mapper_groups/${groupId}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -300,7 +300,9 @@ export const useDeleteSpanMapperGroup = <
 	{ pathParams: DeleteSpanMapperGroupPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteSpanMapperGroupMutationOptions(options));
+	const mutationOptions = getDeleteSpanMapperGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Partially updates an existing mapping group's name, condition, or enabled state.
@@ -308,15 +310,13 @@ export const useDeleteSpanMapperGroup = <
  */
 export const updateSpanMapperGroup = (
 	{ groupId }: UpdateSpanMapperGroupPathParameters,
-	spantypesUpdatableSpanMapperGroupDTO?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>,
-	signal?: AbortSignal,
+	spantypesUpdatableSpanMapperGroupDTO: BodyType<SpantypesUpdatableSpanMapperGroupDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/span_mapper_groups/${groupId}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: spantypesUpdatableSpanMapperGroupDTO,
-		signal,
 	});
 };
 
@@ -329,7 +329,7 @@ export const getUpdateSpanMapperGroupMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateSpanMapperGroupPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 		},
 		TContext
 	>;
@@ -338,7 +338,7 @@ export const getUpdateSpanMapperGroupMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateSpanMapperGroupPathParameters;
-		data?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
+		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 	},
 	TContext
 > => {
@@ -355,7 +355,7 @@ export const getUpdateSpanMapperGroupMutationOptions = <
 		Awaited<ReturnType<typeof updateSpanMapperGroup>>,
 		{
 			pathParams: UpdateSpanMapperGroupPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -370,8 +370,7 @@ export type UpdateSpanMapperGroupMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateSpanMapperGroup>>
 >;
 export type UpdateSpanMapperGroupMutationBody =
-	| BodyType<SpantypesUpdatableSpanMapperGroupDTO>
-	| undefined;
+	BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 export type UpdateSpanMapperGroupMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -387,7 +386,7 @@ export const useUpdateSpanMapperGroup = <
 		TError,
 		{
 			pathParams: UpdateSpanMapperGroupPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 		},
 		TContext
 	>;
@@ -396,11 +395,13 @@ export const useUpdateSpanMapperGroup = <
 	TError,
 	{
 		pathParams: UpdateSpanMapperGroupPathParameters;
-		data?: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
+		data: BodyType<SpantypesUpdatableSpanMapperGroupDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateSpanMapperGroupMutationOptions(options));
+	const mutationOptions = getUpdateSpanMapperGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Returns all mappers belonging to a mapping group.
@@ -485,7 +486,9 @@ export function useListSpanMappers<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -510,7 +513,7 @@ export const invalidateListSpanMappers = async (
  */
 export const createSpanMapper = (
 	{ groupId }: CreateSpanMapperPathParameters,
-	spantypesPostableSpanMapperDTO?: BodyType<SpantypesPostableSpanMapperDTO>,
+	spantypesPostableSpanMapperDTO: BodyType<SpantypesPostableSpanMapperDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateSpanMapper201>({
@@ -531,7 +534,7 @@ export const getCreateSpanMapperMutationOptions = <
 		TError,
 		{
 			pathParams: CreateSpanMapperPathParameters;
-			data?: BodyType<SpantypesPostableSpanMapperDTO>;
+			data: BodyType<SpantypesPostableSpanMapperDTO>;
 		},
 		TContext
 	>;
@@ -540,7 +543,7 @@ export const getCreateSpanMapperMutationOptions = <
 	TError,
 	{
 		pathParams: CreateSpanMapperPathParameters;
-		data?: BodyType<SpantypesPostableSpanMapperDTO>;
+		data: BodyType<SpantypesPostableSpanMapperDTO>;
 	},
 	TContext
 > => {
@@ -557,7 +560,7 @@ export const getCreateSpanMapperMutationOptions = <
 		Awaited<ReturnType<typeof createSpanMapper>>,
 		{
 			pathParams: CreateSpanMapperPathParameters;
-			data?: BodyType<SpantypesPostableSpanMapperDTO>;
+			data: BodyType<SpantypesPostableSpanMapperDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -572,8 +575,7 @@ export type CreateSpanMapperMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createSpanMapper>>
 >;
 export type CreateSpanMapperMutationBody =
-	| BodyType<SpantypesPostableSpanMapperDTO>
-	| undefined;
+	BodyType<SpantypesPostableSpanMapperDTO>;
 export type CreateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -588,7 +590,7 @@ export const useCreateSpanMapper = <
 		TError,
 		{
 			pathParams: CreateSpanMapperPathParameters;
-			data?: BodyType<SpantypesPostableSpanMapperDTO>;
+			data: BodyType<SpantypesPostableSpanMapperDTO>;
 		},
 		TContext
 	>;
@@ -597,24 +599,25 @@ export const useCreateSpanMapper = <
 	TError,
 	{
 		pathParams: CreateSpanMapperPathParameters;
-		data?: BodyType<SpantypesPostableSpanMapperDTO>;
+		data: BodyType<SpantypesPostableSpanMapperDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getCreateSpanMapperMutationOptions(options));
+	const mutationOptions = getCreateSpanMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Hard-deletes a mapper from a mapping group.
  * @summary Delete a span mapper
  */
-export const deleteSpanMapper = (
-	{ groupId, mapperId }: DeleteSpanMapperPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteSpanMapper = ({
+	groupId,
+	mapperId,
+}: DeleteSpanMapperPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -680,7 +683,9 @@ export const useDeleteSpanMapper = <
 	{ pathParams: DeleteSpanMapperPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteSpanMapperMutationOptions(options));
+	const mutationOptions = getDeleteSpanMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * Partially updates an existing mapper's field context, config, or enabled state.
@@ -688,15 +693,13 @@ export const useDeleteSpanMapper = <
  */
 export const updateSpanMapper = (
 	{ groupId, mapperId }: UpdateSpanMapperPathParameters,
-	spantypesUpdatableSpanMapperDTO?: BodyType<SpantypesUpdatableSpanMapperDTO>,
-	signal?: AbortSignal,
+	spantypesUpdatableSpanMapperDTO: BodyType<SpantypesUpdatableSpanMapperDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/span_mapper_groups/${groupId}/span_mappers/${mapperId}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
 		data: spantypesUpdatableSpanMapperDTO,
-		signal,
 	});
 };
 
@@ -709,7 +712,7 @@ export const getUpdateSpanMapperMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateSpanMapperPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
 		},
 		TContext
 	>;
@@ -718,7 +721,7 @@ export const getUpdateSpanMapperMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateSpanMapperPathParameters;
-		data?: BodyType<SpantypesUpdatableSpanMapperDTO>;
+		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
 	},
 	TContext
 > => {
@@ -735,7 +738,7 @@ export const getUpdateSpanMapperMutationOptions = <
 		Awaited<ReturnType<typeof updateSpanMapper>>,
 		{
 			pathParams: UpdateSpanMapperPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -750,8 +753,7 @@ export type UpdateSpanMapperMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateSpanMapper>>
 >;
 export type UpdateSpanMapperMutationBody =
-	| BodyType<SpantypesUpdatableSpanMapperDTO>
-	| undefined;
+	BodyType<SpantypesUpdatableSpanMapperDTO>;
 export type UpdateSpanMapperMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -766,7 +768,7 @@ export const useUpdateSpanMapper = <
 		TError,
 		{
 			pathParams: UpdateSpanMapperPathParameters;
-			data?: BodyType<SpantypesUpdatableSpanMapperDTO>;
+			data: BodyType<SpantypesUpdatableSpanMapperDTO>;
 		},
 		TContext
 	>;
@@ -775,9 +777,11 @@ export const useUpdateSpanMapper = <
 	TError,
 	{
 		pathParams: UpdateSpanMapperPathParameters;
-		data?: BodyType<SpantypesUpdatableSpanMapperDTO>;
+		data: BodyType<SpantypesUpdatableSpanMapperDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateSpanMapperMutationOptions(options));
+	const mutationOptions = getUpdateSpanMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/tracedetail/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation } from 'react-query';
 import type {
@@ -28,7 +27,7 @@ import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
  */
 export const getWaterfall = (
 	{ traceID }: GetWaterfallPathParameters,
-	tracedetailtypesPostableWaterfallDTO?: BodyType<TracedetailtypesPostableWaterfallDTO>,
+	tracedetailtypesPostableWaterfallDTO: BodyType<TracedetailtypesPostableWaterfallDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<GetWaterfall200>({
@@ -49,7 +48,7 @@ export const getGetWaterfallMutationOptions = <
 		TError,
 		{
 			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<TracedetailtypesPostableWaterfallDTO>;
+			data: BodyType<TracedetailtypesPostableWaterfallDTO>;
 		},
 		TContext
 	>;
@@ -58,7 +57,7 @@ export const getGetWaterfallMutationOptions = <
 	TError,
 	{
 		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<TracedetailtypesPostableWaterfallDTO>;
+		data: BodyType<TracedetailtypesPostableWaterfallDTO>;
 	},
 	TContext
 > => {
@@ -75,7 +74,7 @@ export const getGetWaterfallMutationOptions = <
 		Awaited<ReturnType<typeof getWaterfall>>,
 		{
 			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<TracedetailtypesPostableWaterfallDTO>;
+			data: BodyType<TracedetailtypesPostableWaterfallDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -90,8 +89,7 @@ export type GetWaterfallMutationResult = NonNullable<
 	Awaited<ReturnType<typeof getWaterfall>>
 >;
 export type GetWaterfallMutationBody =
-	| BodyType<TracedetailtypesPostableWaterfallDTO>
-	| undefined;
+	BodyType<TracedetailtypesPostableWaterfallDTO>;
 export type GetWaterfallMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -106,7 +104,7 @@ export const useGetWaterfall = <
 		TError,
 		{
 			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<TracedetailtypesPostableWaterfallDTO>;
+			data: BodyType<TracedetailtypesPostableWaterfallDTO>;
 		},
 		TContext
 	>;
@@ -115,9 +113,11 @@ export const useGetWaterfall = <
 	TError,
 	{
 		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<TracedetailtypesPostableWaterfallDTO>;
+		data: BodyType<TracedetailtypesPostableWaterfallDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getGetWaterfallMutationOptions(options));
+	const mutationOptions = getGetWaterfallMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/users/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -147,7 +146,9 @@ export function useGetResetPasswordTokenDeprecated<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -172,7 +173,7 @@ export const invalidateGetResetPasswordTokenDeprecated = async (
  * @summary Create invite
  */
 export const createInvite = (
-	typesPostableInviteDTO?: BodyType<TypesPostableInviteDTO>,
+	typesPostableInviteDTO: BodyType<TypesPostableInviteDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateInvite201>({
@@ -191,13 +192,13 @@ export const getCreateInviteMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createInvite>>,
 		TError,
-		{ data?: BodyType<TypesPostableInviteDTO> },
+		{ data: BodyType<TypesPostableInviteDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createInvite>>,
 	TError,
-	{ data?: BodyType<TypesPostableInviteDTO> },
+	{ data: BodyType<TypesPostableInviteDTO> },
 	TContext
 > => {
 	const mutationKey = ['createInvite'];
@@ -211,7 +212,7 @@ export const getCreateInviteMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createInvite>>,
-		{ data?: BodyType<TypesPostableInviteDTO> }
+		{ data: BodyType<TypesPostableInviteDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -224,9 +225,7 @@ export const getCreateInviteMutationOptions = <
 export type CreateInviteMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createInvite>>
 >;
-export type CreateInviteMutationBody =
-	| BodyType<TypesPostableInviteDTO>
-	| undefined;
+export type CreateInviteMutationBody = BodyType<TypesPostableInviteDTO>;
 export type CreateInviteMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -239,23 +238,25 @@ export const useCreateInvite = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createInvite>>,
 		TError,
-		{ data?: BodyType<TypesPostableInviteDTO> },
+		{ data: BodyType<TypesPostableInviteDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createInvite>>,
 	TError,
-	{ data?: BodyType<TypesPostableInviteDTO> },
+	{ data: BodyType<TypesPostableInviteDTO> },
 	TContext
 > => {
-	return useMutation(getCreateInviteMutationOptions(options));
+	const mutationOptions = getCreateInviteMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint creates a bulk invite for a user
  * @summary Create bulk invite
  */
 export const createBulkInvite = (
-	typesPostableBulkInviteRequestDTO?: BodyType<TypesPostableBulkInviteRequestDTO>,
+	typesPostableBulkInviteRequestDTO: BodyType<TypesPostableBulkInviteRequestDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -274,13 +275,13 @@ export const getCreateBulkInviteMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createBulkInvite>>,
 		TError,
-		{ data?: BodyType<TypesPostableBulkInviteRequestDTO> },
+		{ data: BodyType<TypesPostableBulkInviteRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createBulkInvite>>,
 	TError,
-	{ data?: BodyType<TypesPostableBulkInviteRequestDTO> },
+	{ data: BodyType<TypesPostableBulkInviteRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['createBulkInvite'];
@@ -294,7 +295,7 @@ export const getCreateBulkInviteMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createBulkInvite>>,
-		{ data?: BodyType<TypesPostableBulkInviteRequestDTO> }
+		{ data: BodyType<TypesPostableBulkInviteRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -308,8 +309,7 @@ export type CreateBulkInviteMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createBulkInvite>>
 >;
 export type CreateBulkInviteMutationBody =
-	| BodyType<TypesPostableBulkInviteRequestDTO>
-	| undefined;
+	BodyType<TypesPostableBulkInviteRequestDTO>;
 export type CreateBulkInviteMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -322,23 +322,25 @@ export const useCreateBulkInvite = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createBulkInvite>>,
 		TError,
-		{ data?: BodyType<TypesPostableBulkInviteRequestDTO> },
+		{ data: BodyType<TypesPostableBulkInviteRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createBulkInvite>>,
 	TError,
-	{ data?: BodyType<TypesPostableBulkInviteRequestDTO> },
+	{ data: BodyType<TypesPostableBulkInviteRequestDTO> },
 	TContext
 > => {
-	return useMutation(getCreateBulkInviteMutationOptions(options));
+	const mutationOptions = getCreateBulkInviteMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint resets the password by token
  * @summary Reset password
  */
 export const resetPassword = (
-	typesPostableResetPasswordDTO?: BodyType<TypesPostableResetPasswordDTO>,
+	typesPostableResetPasswordDTO: BodyType<TypesPostableResetPasswordDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -357,13 +359,13 @@ export const getResetPasswordMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof resetPassword>>,
 		TError,
-		{ data?: BodyType<TypesPostableResetPasswordDTO> },
+		{ data: BodyType<TypesPostableResetPasswordDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof resetPassword>>,
 	TError,
-	{ data?: BodyType<TypesPostableResetPasswordDTO> },
+	{ data: BodyType<TypesPostableResetPasswordDTO> },
 	TContext
 > => {
 	const mutationKey = ['resetPassword'];
@@ -377,7 +379,7 @@ export const getResetPasswordMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof resetPassword>>,
-		{ data?: BodyType<TypesPostableResetPasswordDTO> }
+		{ data: BodyType<TypesPostableResetPasswordDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -390,9 +392,7 @@ export const getResetPasswordMutationOptions = <
 export type ResetPasswordMutationResult = NonNullable<
 	Awaited<ReturnType<typeof resetPassword>>
 >;
-export type ResetPasswordMutationBody =
-	| BodyType<TypesPostableResetPasswordDTO>
-	| undefined;
+export type ResetPasswordMutationBody = BodyType<TypesPostableResetPasswordDTO>;
 export type ResetPasswordMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -405,16 +405,18 @@ export const useResetPassword = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof resetPassword>>,
 		TError,
-		{ data?: BodyType<TypesPostableResetPasswordDTO> },
+		{ data: BodyType<TypesPostableResetPasswordDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof resetPassword>>,
 	TError,
-	{ data?: BodyType<TypesPostableResetPasswordDTO> },
+	{ data: BodyType<TypesPostableResetPasswordDTO> },
 	TContext
 > => {
-	return useMutation(getResetPasswordMutationOptions(options));
+	const mutationOptions = getResetPasswordMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint lists all users
@@ -482,7 +484,9 @@ export function useListUsersDeprecated<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -504,14 +508,10 @@ export const invalidateListUsersDeprecated = async (
  * This endpoint deletes the user by id
  * @summary Delete user
  */
-export const deleteUser = (
-	{ id }: DeleteUserPathParameters,
-	signal?: AbortSignal,
-) => {
+export const deleteUser = ({ id }: DeleteUserPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/user/${id}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -577,7 +577,9 @@ export const useDeleteUser = <
 	{ pathParams: DeleteUserPathParameters },
 	TContext
 > => {
-	return useMutation(getDeleteUserMutationOptions(options));
+	const mutationOptions = getDeleteUserMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the user by id
@@ -662,7 +664,9 @@ export function useGetUserDeprecated<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -687,15 +691,13 @@ export const invalidateGetUserDeprecated = async (
  */
 export const updateUserDeprecated = (
 	{ id }: UpdateUserDeprecatedPathParameters,
-	typesDeprecatedUserDTO?: BodyType<TypesDeprecatedUserDTO>,
-	signal?: AbortSignal,
+	typesDeprecatedUserDTO: BodyType<TypesDeprecatedUserDTO>,
 ) => {
 	return GeneratedAPIInstance<UpdateUserDeprecated200>({
 		url: `/api/v1/user/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: typesDeprecatedUserDTO,
-		signal,
 	});
 };
 
@@ -708,7 +710,7 @@ export const getUpdateUserDeprecatedMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateUserDeprecatedPathParameters;
-			data?: BodyType<TypesDeprecatedUserDTO>;
+			data: BodyType<TypesDeprecatedUserDTO>;
 		},
 		TContext
 	>;
@@ -717,7 +719,7 @@ export const getUpdateUserDeprecatedMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateUserDeprecatedPathParameters;
-		data?: BodyType<TypesDeprecatedUserDTO>;
+		data: BodyType<TypesDeprecatedUserDTO>;
 	},
 	TContext
 > => {
@@ -734,7 +736,7 @@ export const getUpdateUserDeprecatedMutationOptions = <
 		Awaited<ReturnType<typeof updateUserDeprecated>>,
 		{
 			pathParams: UpdateUserDeprecatedPathParameters;
-			data?: BodyType<TypesDeprecatedUserDTO>;
+			data: BodyType<TypesDeprecatedUserDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -748,9 +750,7 @@ export const getUpdateUserDeprecatedMutationOptions = <
 export type UpdateUserDeprecatedMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateUserDeprecated>>
 >;
-export type UpdateUserDeprecatedMutationBody =
-	| BodyType<TypesDeprecatedUserDTO>
-	| undefined;
+export type UpdateUserDeprecatedMutationBody = BodyType<TypesDeprecatedUserDTO>;
 export type UpdateUserDeprecatedMutationError =
 	ErrorType<RenderErrorResponseDTO>;
 
@@ -766,7 +766,7 @@ export const useUpdateUserDeprecated = <
 		TError,
 		{
 			pathParams: UpdateUserDeprecatedPathParameters;
-			data?: BodyType<TypesDeprecatedUserDTO>;
+			data: BodyType<TypesDeprecatedUserDTO>;
 		},
 		TContext
 	>;
@@ -775,11 +775,13 @@ export const useUpdateUserDeprecated = <
 	TError,
 	{
 		pathParams: UpdateUserDeprecatedPathParameters;
-		data?: BodyType<TypesDeprecatedUserDTO>;
+		data: BodyType<TypesDeprecatedUserDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateUserDeprecatedMutationOptions(options));
+	const mutationOptions = getUpdateUserDeprecatedMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the user I belong to
@@ -847,7 +849,9 @@ export function useGetMyUserDeprecated<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -870,7 +874,7 @@ export const invalidateGetMyUserDeprecated = async (
  * @summary Forgot password
  */
 export const forgotPassword = (
-	typesPostableForgotPasswordDTO?: BodyType<TypesPostableForgotPasswordDTO>,
+	typesPostableForgotPasswordDTO: BodyType<TypesPostableForgotPasswordDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -889,13 +893,13 @@ export const getForgotPasswordMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof forgotPassword>>,
 		TError,
-		{ data?: BodyType<TypesPostableForgotPasswordDTO> },
+		{ data: BodyType<TypesPostableForgotPasswordDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof forgotPassword>>,
 	TError,
-	{ data?: BodyType<TypesPostableForgotPasswordDTO> },
+	{ data: BodyType<TypesPostableForgotPasswordDTO> },
 	TContext
 > => {
 	const mutationKey = ['forgotPassword'];
@@ -909,7 +913,7 @@ export const getForgotPasswordMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof forgotPassword>>,
-		{ data?: BodyType<TypesPostableForgotPasswordDTO> }
+		{ data: BodyType<TypesPostableForgotPasswordDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -923,8 +927,7 @@ export type ForgotPasswordMutationResult = NonNullable<
 	Awaited<ReturnType<typeof forgotPassword>>
 >;
 export type ForgotPasswordMutationBody =
-	| BodyType<TypesPostableForgotPasswordDTO>
-	| undefined;
+	BodyType<TypesPostableForgotPasswordDTO>;
 export type ForgotPasswordMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -937,16 +940,18 @@ export const useForgotPassword = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof forgotPassword>>,
 		TError,
-		{ data?: BodyType<TypesPostableForgotPasswordDTO> },
+		{ data: BodyType<TypesPostableForgotPasswordDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof forgotPassword>>,
 	TError,
-	{ data?: BodyType<TypesPostableForgotPasswordDTO> },
+	{ data: BodyType<TypesPostableForgotPasswordDTO> },
 	TContext
 > => {
-	return useMutation(getForgotPasswordMutationOptions(options));
+	const mutationOptions = getForgotPasswordMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the users having the role by role id
@@ -1030,7 +1035,9 @@ export function useGetUsersByRoleID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1107,7 +1114,9 @@ export function useListUsers<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1195,7 +1204,9 @@ export function useGetUser<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1220,15 +1231,13 @@ export const invalidateGetUser = async (
  */
 export const updateUser = (
 	{ id }: UpdateUserPathParameters,
-	typesUpdatableUserDTO?: BodyType<TypesUpdatableUserDTO>,
-	signal?: AbortSignal,
+	typesUpdatableUserDTO: BodyType<TypesUpdatableUserDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/users/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: typesUpdatableUserDTO,
-		signal,
 	});
 };
 
@@ -1241,7 +1250,7 @@ export const getUpdateUserMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateUserPathParameters;
-			data?: BodyType<TypesUpdatableUserDTO>;
+			data: BodyType<TypesUpdatableUserDTO>;
 		},
 		TContext
 	>;
@@ -1250,7 +1259,7 @@ export const getUpdateUserMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateUserPathParameters;
-		data?: BodyType<TypesUpdatableUserDTO>;
+		data: BodyType<TypesUpdatableUserDTO>;
 	},
 	TContext
 > => {
@@ -1267,7 +1276,7 @@ export const getUpdateUserMutationOptions = <
 		Awaited<ReturnType<typeof updateUser>>,
 		{
 			pathParams: UpdateUserPathParameters;
-			data?: BodyType<TypesUpdatableUserDTO>;
+			data: BodyType<TypesUpdatableUserDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -1281,9 +1290,7 @@ export const getUpdateUserMutationOptions = <
 export type UpdateUserMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateUser>>
 >;
-export type UpdateUserMutationBody =
-	| BodyType<TypesUpdatableUserDTO>
-	| undefined;
+export type UpdateUserMutationBody = BodyType<TypesUpdatableUserDTO>;
 export type UpdateUserMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1298,7 +1305,7 @@ export const useUpdateUser = <
 		TError,
 		{
 			pathParams: UpdateUserPathParameters;
-			data?: BodyType<TypesUpdatableUserDTO>;
+			data: BodyType<TypesUpdatableUserDTO>;
 		},
 		TContext
 	>;
@@ -1307,11 +1314,13 @@ export const useUpdateUser = <
 	TError,
 	{
 		pathParams: UpdateUserPathParameters;
-		data?: BodyType<TypesUpdatableUserDTO>;
+		data: BodyType<TypesUpdatableUserDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getUpdateUserMutationOptions(options));
+	const mutationOptions = getUpdateUserMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the existing reset password token for a user.
@@ -1396,7 +1405,9 @@ export function useGetResetPasswordToken<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1419,14 +1430,12 @@ export const invalidateGetResetPasswordToken = async (
  * This endpoint creates or regenerates a reset password token for a user. If a valid token exists, it is returned. If expired, a new one is created.
  * @summary Create or regenerate reset password token for a user
  */
-export const createResetPasswordToken = (
-	{ id }: CreateResetPasswordTokenPathParameters,
-	signal?: AbortSignal,
-) => {
+export const createResetPasswordToken = ({
+	id,
+}: CreateResetPasswordTokenPathParameters) => {
 	return GeneratedAPIInstance<CreateResetPasswordToken201>({
 		url: `/api/v2/users/${id}/reset_password_tokens`,
 		method: 'PUT',
-		signal,
 	});
 };
 
@@ -1493,7 +1502,9 @@ export const useCreateResetPasswordToken = <
 	{ pathParams: CreateResetPasswordTokenPathParameters },
 	TContext
 > => {
-	return useMutation(getCreateResetPasswordTokenMutationOptions(options));
+	const mutationOptions = getCreateResetPasswordTokenMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the user roles by user id
@@ -1577,7 +1588,9 @@ export function useGetRolesByUserID<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1602,7 +1615,7 @@ export const invalidateGetRolesByUserID = async (
  */
 export const setRoleByUserID = (
 	{ id }: SetRoleByUserIDPathParameters,
-	typesPostableRoleDTO?: BodyType<TypesPostableRoleDTO>,
+	typesPostableRoleDTO: BodyType<TypesPostableRoleDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<void>({
@@ -1623,7 +1636,7 @@ export const getSetRoleByUserIDMutationOptions = <
 		TError,
 		{
 			pathParams: SetRoleByUserIDPathParameters;
-			data?: BodyType<TypesPostableRoleDTO>;
+			data: BodyType<TypesPostableRoleDTO>;
 		},
 		TContext
 	>;
@@ -1632,7 +1645,7 @@ export const getSetRoleByUserIDMutationOptions = <
 	TError,
 	{
 		pathParams: SetRoleByUserIDPathParameters;
-		data?: BodyType<TypesPostableRoleDTO>;
+		data: BodyType<TypesPostableRoleDTO>;
 	},
 	TContext
 > => {
@@ -1649,7 +1662,7 @@ export const getSetRoleByUserIDMutationOptions = <
 		Awaited<ReturnType<typeof setRoleByUserID>>,
 		{
 			pathParams: SetRoleByUserIDPathParameters;
-			data?: BodyType<TypesPostableRoleDTO>;
+			data: BodyType<TypesPostableRoleDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -1663,9 +1676,7 @@ export const getSetRoleByUserIDMutationOptions = <
 export type SetRoleByUserIDMutationResult = NonNullable<
 	Awaited<ReturnType<typeof setRoleByUserID>>
 >;
-export type SetRoleByUserIDMutationBody =
-	| BodyType<TypesPostableRoleDTO>
-	| undefined;
+export type SetRoleByUserIDMutationBody = BodyType<TypesPostableRoleDTO>;
 export type SetRoleByUserIDMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1680,7 +1691,7 @@ export const useSetRoleByUserID = <
 		TError,
 		{
 			pathParams: SetRoleByUserIDPathParameters;
-			data?: BodyType<TypesPostableRoleDTO>;
+			data: BodyType<TypesPostableRoleDTO>;
 		},
 		TContext
 	>;
@@ -1689,24 +1700,25 @@ export const useSetRoleByUserID = <
 	TError,
 	{
 		pathParams: SetRoleByUserIDPathParameters;
-		data?: BodyType<TypesPostableRoleDTO>;
+		data: BodyType<TypesPostableRoleDTO>;
 	},
 	TContext
 > => {
-	return useMutation(getSetRoleByUserIDMutationOptions(options));
+	const mutationOptions = getSetRoleByUserIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint removes a role from the user by user id and role id
  * @summary Remove a role from user
  */
-export const removeUserRoleByUserIDAndRoleID = (
-	{ id, roleId }: RemoveUserRoleByUserIDAndRoleIDPathParameters,
-	signal?: AbortSignal,
-) => {
+export const removeUserRoleByUserIDAndRoleID = ({
+	id,
+	roleId,
+}: RemoveUserRoleByUserIDAndRoleIDPathParameters) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/users/${id}/roles/${roleId}`,
 		method: 'DELETE',
-		signal,
 	});
 };
 
@@ -1773,7 +1785,10 @@ export const useRemoveUserRoleByUserIDAndRoleID = <
 	{ pathParams: RemoveUserRoleByUserIDAndRoleIDPathParameters },
 	TContext
 > => {
-	return useMutation(getRemoveUserRoleByUserIDAndRoleIDMutationOptions(options));
+	const mutationOptions =
+		getRemoveUserRoleByUserIDAndRoleIDMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint returns the user I belong to
@@ -1833,7 +1848,9 @@ export function useGetMyUser<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -1856,15 +1873,13 @@ export const invalidateGetMyUser = async (
  * @summary Update my user v2
  */
 export const updateMyUserV2 = (
-	typesUpdatableUserDTO?: BodyType<TypesUpdatableUserDTO>,
-	signal?: AbortSignal,
+	typesUpdatableUserDTO: BodyType<TypesUpdatableUserDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/users/me`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: typesUpdatableUserDTO,
-		signal,
 	});
 };
 
@@ -1875,13 +1890,13 @@ export const getUpdateMyUserV2MutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyUserV2>>,
 		TError,
-		{ data?: BodyType<TypesUpdatableUserDTO> },
+		{ data: BodyType<TypesUpdatableUserDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof updateMyUserV2>>,
 	TError,
-	{ data?: BodyType<TypesUpdatableUserDTO> },
+	{ data: BodyType<TypesUpdatableUserDTO> },
 	TContext
 > => {
 	const mutationKey = ['updateMyUserV2'];
@@ -1895,7 +1910,7 @@ export const getUpdateMyUserV2MutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof updateMyUserV2>>,
-		{ data?: BodyType<TypesUpdatableUserDTO> }
+		{ data: BodyType<TypesUpdatableUserDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -1908,9 +1923,7 @@ export const getUpdateMyUserV2MutationOptions = <
 export type UpdateMyUserV2MutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateMyUserV2>>
 >;
-export type UpdateMyUserV2MutationBody =
-	| BodyType<TypesUpdatableUserDTO>
-	| undefined;
+export type UpdateMyUserV2MutationBody = BodyType<TypesUpdatableUserDTO>;
 export type UpdateMyUserV2MutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -1923,31 +1936,31 @@ export const useUpdateMyUserV2 = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyUserV2>>,
 		TError,
-		{ data?: BodyType<TypesUpdatableUserDTO> },
+		{ data: BodyType<TypesUpdatableUserDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof updateMyUserV2>>,
 	TError,
-	{ data?: BodyType<TypesUpdatableUserDTO> },
+	{ data: BodyType<TypesUpdatableUserDTO> },
 	TContext
 > => {
-	return useMutation(getUpdateMyUserV2MutationOptions(options));
+	const mutationOptions = getUpdateMyUserV2MutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint updates the password of the user I belong to
  * @summary Updates my password
  */
 export const updateMyPassword = (
-	typesChangePasswordRequestDTO?: BodyType<TypesChangePasswordRequestDTO>,
-	signal?: AbortSignal,
+	typesChangePasswordRequestDTO: BodyType<TypesChangePasswordRequestDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/users/me/factor_password`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: typesChangePasswordRequestDTO,
-		signal,
 	});
 };
 
@@ -1958,13 +1971,13 @@ export const getUpdateMyPasswordMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyPassword>>,
 		TError,
-		{ data?: BodyType<TypesChangePasswordRequestDTO> },
+		{ data: BodyType<TypesChangePasswordRequestDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof updateMyPassword>>,
 	TError,
-	{ data?: BodyType<TypesChangePasswordRequestDTO> },
+	{ data: BodyType<TypesChangePasswordRequestDTO> },
 	TContext
 > => {
 	const mutationKey = ['updateMyPassword'];
@@ -1978,7 +1991,7 @@ export const getUpdateMyPasswordMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof updateMyPassword>>,
-		{ data?: BodyType<TypesChangePasswordRequestDTO> }
+		{ data: BodyType<TypesChangePasswordRequestDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -1992,8 +2005,7 @@ export type UpdateMyPasswordMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateMyPassword>>
 >;
 export type UpdateMyPasswordMutationBody =
-	| BodyType<TypesChangePasswordRequestDTO>
-	| undefined;
+	BodyType<TypesChangePasswordRequestDTO>;
 export type UpdateMyPasswordMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -2006,14 +2018,16 @@ export const useUpdateMyPassword = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof updateMyPassword>>,
 		TError,
-		{ data?: BodyType<TypesChangePasswordRequestDTO> },
+		{ data: BodyType<TypesChangePasswordRequestDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof updateMyPassword>>,
 	TError,
-	{ data?: BodyType<TypesChangePasswordRequestDTO> },
+	{ data: BodyType<TypesChangePasswordRequestDTO> },
 	TContext
 > => {
-	return useMutation(getUpdateMyPasswordMutationOptions(options));
+	const mutationOptions = getUpdateMyPasswordMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/api/generated/services/zeus/index.ts

@@ -1,9 +1,8 @@
 /**
  * ! Do not edit manually
  * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
+ * * regenerate with 'yarn generate:api'
  * SigNoz
- * OpenAPI spec version: 0.0.1
  */
 import { useMutation, useQuery } from 'react-query';
 import type {
@@ -86,7 +85,9 @@ export function useGetHosts<
 		queryKey: QueryKey;
 	};
 
-	return { ...query, queryKey: queryOptions.queryKey };
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
 }
 
 /**
@@ -109,15 +110,13 @@ export const invalidateGetHosts = async (
  * @summary Put host in Zeus for a deployment.
  */
 export const putHost = (
-	zeustypesPostableHostDTO?: BodyType<ZeustypesPostableHostDTO>,
-	signal?: AbortSignal,
+	zeustypesPostableHostDTO: BodyType<ZeustypesPostableHostDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/zeus/hosts`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: zeustypesPostableHostDTO,
-		signal,
 	});
 };
 
@@ -128,13 +127,13 @@ export const getPutHostMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof putHost>>,
 		TError,
-		{ data?: BodyType<ZeustypesPostableHostDTO> },
+		{ data: BodyType<ZeustypesPostableHostDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof putHost>>,
 	TError,
-	{ data?: BodyType<ZeustypesPostableHostDTO> },
+	{ data: BodyType<ZeustypesPostableHostDTO> },
 	TContext
 > => {
 	const mutationKey = ['putHost'];
@@ -148,7 +147,7 @@ export const getPutHostMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof putHost>>,
-		{ data?: BodyType<ZeustypesPostableHostDTO> }
+		{ data: BodyType<ZeustypesPostableHostDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -161,9 +160,7 @@ export const getPutHostMutationOptions = <
 export type PutHostMutationResult = NonNullable<
 	Awaited<ReturnType<typeof putHost>>
 >;
-export type PutHostMutationBody =
-	| BodyType<ZeustypesPostableHostDTO>
-	| undefined;
+export type PutHostMutationBody = BodyType<ZeustypesPostableHostDTO>;
 export type PutHostMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -176,31 +173,31 @@ export const usePutHost = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof putHost>>,
 		TError,
-		{ data?: BodyType<ZeustypesPostableHostDTO> },
+		{ data: BodyType<ZeustypesPostableHostDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof putHost>>,
 	TError,
-	{ data?: BodyType<ZeustypesPostableHostDTO> },
+	{ data: BodyType<ZeustypesPostableHostDTO> },
 	TContext
 > => {
-	return useMutation(getPutHostMutationOptions(options));
+	const mutationOptions = getPutHostMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };
 /**
  * This endpoint saves the profile of a deployment to zeus.
  * @summary Put profile in Zeus for a deployment.
  */
 export const putProfile = (
-	zeustypesPostableProfileDTO?: BodyType<ZeustypesPostableProfileDTO>,
-	signal?: AbortSignal,
+	zeustypesPostableProfileDTO: BodyType<ZeustypesPostableProfileDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v2/zeus/profiles`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
 		data: zeustypesPostableProfileDTO,
-		signal,
 	});
 };
 
@@ -211,13 +208,13 @@ export const getPutProfileMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof putProfile>>,
 		TError,
-		{ data?: BodyType<ZeustypesPostableProfileDTO> },
+		{ data: BodyType<ZeustypesPostableProfileDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof putProfile>>,
 	TError,
-	{ data?: BodyType<ZeustypesPostableProfileDTO> },
+	{ data: BodyType<ZeustypesPostableProfileDTO> },
 	TContext
 > => {
 	const mutationKey = ['putProfile'];
@@ -231,7 +228,7 @@ export const getPutProfileMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof putProfile>>,
-		{ data?: BodyType<ZeustypesPostableProfileDTO> }
+		{ data: BodyType<ZeustypesPostableProfileDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -244,9 +241,7 @@ export const getPutProfileMutationOptions = <
 export type PutProfileMutationResult = NonNullable<
 	Awaited<ReturnType<typeof putProfile>>
 >;
-export type PutProfileMutationBody =
-	| BodyType<ZeustypesPostableProfileDTO>
-	| undefined;
+export type PutProfileMutationBody = BodyType<ZeustypesPostableProfileDTO>;
 export type PutProfileMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -259,14 +254,16 @@ export const usePutProfile = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof putProfile>>,
 		TError,
-		{ data?: BodyType<ZeustypesPostableProfileDTO> },
+		{ data: BodyType<ZeustypesPostableProfileDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof putProfile>>,
 	TError,
-	{ data?: BodyType<ZeustypesPostableProfileDTO> },
+	{ data: BodyType<ZeustypesPostableProfileDTO> },
 	TContext
 > => {
-	return useMutation(getPutProfileMutationOptions(options));
+	const mutationOptions = getPutProfileMutationOptions(options);
+
+	return useMutation(mutationOptions);
 };

frontend/src/components/AuthError/AuthError.tsx

@@ -1,5 +1,5 @@
 import ErrorContent from 'components/ErrorModal/components/ErrorContent';
-import { CircleAlert } from '@signozhq/icons';
+import { CircleAlert } from 'lucide-react';
 import APIError from 'types/api/error';
 
 import './AuthError.styles.scss';

frontend/src/components/AuthPageContainer/AuthFooter.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ArrowUpRight } from '@signozhq/icons';
+import { ArrowUpRight } from 'lucide-react';
 
 import './AuthFooter.styles.scss';
 

frontend/src/components/AuthPageContainer/AuthHeader.tsx

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { Button } from '@signozhq/ui/button';
-import { LifeBuoy } from '@signozhq/icons';
+import { LifeBuoy } from 'lucide-react';
 
 import signozBrandLogoUrl from '@/assets/Logos/signoz-brand-logo.svg';
 

frontend/src/components/CeleryOverview/CeleryOverviewTable/CeleryOverviewTable.tsx

@@ -2,11 +2,10 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useMutation } from 'react-query';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
-import { Loader, Search } from '@signozhq/icons';
+import { LoadingOutlined, SearchOutlined } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
 import {
 	Button,
-	Flex,
 	Input,
 	InputRef,
 	Progress,
@@ -108,11 +107,9 @@ const getColumnSearchProps = (
 					type="primary"
 					size="small"
 					onClick={(): void => handleSearch(selectedKeys as string[], confirm)}
+					icon={<SearchOutlined />}
 				>
-					<Flex align="center" gap={4}>
-						<Search size="md" />
-						Search
-					</Flex>
+					Search
 				</Button>
 				<Button
 					onClick={(): void => clearFilters && handleReset(clearFilters, confirm)}
@@ -134,9 +131,8 @@ const getColumnSearchProps = (
 		</div>
 	),
 	filterIcon: (filtered: boolean): JSX.Element => (
-		<Search
+		<SearchOutlined
 			style={{ color: filtered ? Color.BG_ROBIN_500 : undefined }}
-			size="md"
 		/>
 	),
 	onFilter: (value, record): boolean =>
@@ -520,9 +516,7 @@ export default function CeleryOverviewTable({
 				bordered={false}
 				loading={{
 					spinning: isLoading,
-					indicator: (
-						<Spin indicator={<Loader size={14} className="animate-spin" />} />
-					),
+					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
 				}}
 				locale={{
 					emptyText: isLoading ? null : <Typography.Text>No data</Typography.Text>,

frontend/src/components/CeleryTask/CeleryTaskDetail/CeleryTaskDetail.tsx

@@ -6,7 +6,7 @@ import logEvent from 'api/common/logEvent';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import dayjs from 'dayjs';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { X } from '@signozhq/icons';
+import { X } from 'lucide-react';
 import { Widgets } from 'types/api/dashboard/getAll';
 import { MetricRangePayloadProps } from 'types/api/metrics/getQueryRange';
 import { DataSource } from 'types/common/queryBuilder';

frontend/src/components/CeleryTask/CeleryTaskGraph/CeleryTaskGraphGrid.tsx

@@ -6,7 +6,7 @@ import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import { CardContainer } from 'container/GridCardLayout/styles';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { ChevronDown, ChevronUp } from '@signozhq/icons';
+import { ChevronDown, ChevronUp } from 'lucide-react';
 import { AppState } from 'store/reducers';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { DataSource } from 'types/common/queryBuilder';

frontend/src/components/ChangePercentagePill/ChangePercentagePill.tsx

@@ -1,6 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
 import cx from 'classnames';
-import { ArrowDown, ArrowUp } from '@signozhq/icons';
+import { ArrowDown, ArrowUp } from 'lucide-react';
 
 import './ChangePercentagePill.styles.scss';
 

frontend/src/components/ChangelogModal/ChangelogModal.tsx

@@ -1,12 +1,13 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useMutation } from 'react-query';
-import { Check, ChevronsDown, ScrollText, X } from '@signozhq/icons';
-import { Button, Flex, Modal } from 'antd';
+import { CheckOutlined, CloseOutlined } from '@ant-design/icons';
+import { Button, Modal } from 'antd';
 import updateUserPreference from 'api/v1/user/preferences/name/update';
 import cx from 'classnames';
 import { USER_PREFERENCES } from 'constants/userPreferences';
 import dayjs from 'dayjs';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
+import { ChevronsDown, ScrollText } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { ChangelogSchema } from 'types/api/changelog/getChangelogByVersion';
 import { UserPreference } from 'types/api/preferences/preference';
@@ -115,17 +116,15 @@ function ChangelogModal({ changelog, onClose }: Props): JSX.Element {
 				>
 					{!isCloudUser && (
 						<div className="changelog-modal-footer-ctas">
-							<Button type="default" onClick={onClose}>
-								<Flex align="center" gap="4px">
-									<X size="md" />
-									Skip for now
-								</Flex>
+							<Button type="default" icon={<CloseOutlined />} onClick={onClose}>
+								Skip for now
 							</Button>
-							<Button type="primary" onClick={onClickUpdateWorkspace}>
-								<Flex align="center" gap="4px">
-									<Check size="md" />
-									Update my workspace
-								</Flex>
+							<Button
+								type="primary"
+								icon={<CheckOutlined />}
+								onClick={onClickUpdateWorkspace}
+							>
+								Update my workspace
 							</Button>
 						</div>
 					)}

frontend/src/components/ChatSupportGateway/ChatSupportGateway.tsx

@@ -6,7 +6,7 @@ import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import updateCreditCardApi from 'api/v1/checkout/create';
 import { useNotifications } from 'hooks/useNotifications';
-import { CreditCard, MessageSquareText, X } from '@signozhq/icons';
+import { CreditCard, MessageSquareText, X } from 'lucide-react';
 import { SuccessResponseV2 } from 'types/api';
 import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
 import APIError from 'types/api/error';

frontend/src/components/ClientSideQBSearch/ClientSideQBSearch.tsx

@@ -37,7 +37,7 @@ import { validationMapper } from 'hooks/queryBuilder/useIsValidTag';
 import { operatorTypeMapper } from 'hooks/queryBuilder/useOperatorType';
 import { useIsDarkMode } from 'hooks/useDarkMode';
 import { isArray, isEmpty, isEqual, isObject } from 'lodash-es';
-import { ChevronDown, ChevronUp } from '@signozhq/icons';
+import { ChevronDown, ChevronUp } from 'lucide-react';
 import type { BaseSelectRef } from 'rc-select';
 import {
 	BaseAutocompleteData,

frontend/src/components/CloudIntegrations/CloudServiceDataCollected/CloudServiceDataCollected.tsx

@@ -3,7 +3,7 @@ import {
 	CloudintegrationtypesCollectedLogAttributeDTO,
 	CloudintegrationtypesCollectedMetricDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import { BarChart, ScrollText } from '@signozhq/icons';
+import { BarChart2, ScrollText } from 'lucide-react';
 
 import './CloudServiceDataCollected.styles.scss';
 
@@ -82,7 +82,7 @@ function CloudServiceDataCollected({
 			{metricsData && metricsData.length > 0 && (
 				<div className="cloud-service-data-collected-table">
 					<div className="cloud-service-data-collected-table-heading">
-						<BarChart size={14} />
+						<BarChart2 size={14} />
 						Metrics
 					</div>
 					<Table

frontend/src/components/CustomTimePicker/CalendarContainer.tsx

@@ -2,7 +2,7 @@ import { Calendar } from '@signozhq/ui/calendar';
 import { Button } from 'antd';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
-import { Calendar as CalendarIcon, Check, X } from '@signozhq/icons';
+import { CalendarIcon, Check, X } from 'lucide-react';
 import { useTimezone } from 'providers/Timezone';
 
 import { DateRange } from './CustomTimePickerPopoverContent';

frontend/src/components/CustomTimePicker/CustomTimePicker.tsx

@@ -23,7 +23,7 @@ import { useZoomOut } from 'hooks/useZoomOut';
 import { isValidShortHandDateTimeFormat } from 'lib/getMinMax';
 import { isZoomOutDisabled } from 'lib/zoomOutUtils';
 import { defaultTo, isFunction, noop } from 'lodash-es';
-import { ChevronDown, ChevronUp, ZoomOut } from '@signozhq/icons';
+import { ChevronDown, ChevronUp, ZoomOut } from 'lucide-react';
 import { useTimezone } from 'providers/Timezone';
 import { getTimeDifference, validateEpochRange } from 'utils/epochUtils';
 import { popupContainer } from 'utils/selectPopupContainer';

frontend/src/components/CustomTimePicker/CustomTimePickerPopoverContent.tsx

@@ -21,7 +21,7 @@ import {
 	Option,
 } from 'container/TopNav/DateTimeSelectionV2/types';
 import dayjs from 'dayjs';
-import { Clock, PenLine, TriangleAlert } from '@signozhq/icons';
+import { Clock, PenLine, TriangleAlertIcon } from 'lucide-react';
 import { useTimezone } from 'providers/Timezone';
 import { getCustomTimeRanges } from 'utils/customTimeRangeUtils';
 import { TimeRangeValidationResult } from 'utils/timeUtils';
@@ -300,7 +300,7 @@ function CustomTimePickerPopoverContent({
 								inputErrorDetails && (
 									<div className="input-error-message-container">
 										<div className="input-error-message-title">
-											<TriangleAlert color={Color.BG_CHERRY_400} size={16} />
+											<TriangleAlertIcon color={Color.BG_CHERRY_400} size={16} />
 											<span className="input-error-message-text">
 												{inputErrorDetails.message}
 											</span>

frontend/src/components/CustomTimePicker/TimezonePicker.tsx

@@ -11,7 +11,7 @@ import logEvent from 'api/common/logEvent';
 import cx from 'classnames';
 import { TimezonePickerShortcuts } from 'constants/shortcuts/TimezonePickerShortcuts';
 import { useKeyboardHotkeys } from 'hooks/hotkeys/useKeyboardHotkeys';
-import { Check, Search } from '@signozhq/icons';
+import { Check, Search } from 'lucide-react';
 import { useTimezone } from 'providers/Timezone';
 
 import { Timezone, TIMEZONE_DATA } from './timezoneUtils';

frontend/src/components/DownloadOptionsMenu/DownloadOptionsMenu.tsx

@@ -3,7 +3,7 @@ import { Button, Popover, Radio, Tooltip } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { useExportRawData } from 'hooks/useDownloadOptionsMenu/useDownloadOptionsMenu';
-import { Download, LoaderCircle } from '@signozhq/icons';
+import { Download, DownloadIcon, Loader2 } from 'lucide-react';
 import { DataSource } from 'types/common/queryBuilder';
 
 import {
@@ -140,9 +140,9 @@ export default function DownloadOptionsMenu({
 					className="periscope-btn ghost"
 					icon={
 						isDownloading ? (
-							<LoaderCircle size={14} className="animate-spin" />
+							<Loader2 size={14} className="animate-spin" />
 						) : (
-							<Download size={14} />
+							<DownloadIcon size={14} />
 						)
 					}
 					data-testid={`periscope-btn-download-${dataSource}`}

frontend/src/components/DropDown/DropDown.tsx

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { Ellipsis } from '@signozhq/icons';
+import { EllipsisOutlined } from '@ant-design/icons';
 import { Button, Dropdown, MenuProps } from 'antd';
 
 import './DropDown.styles.scss';
@@ -38,7 +38,7 @@ function DropDown({
 					setDdOpen(true);
 				}}
 			>
-				<Ellipsis className="dropdown-icon" size={16} />
+				<EllipsisOutlined className="dropdown-icon" />
 			</Button>
 		</Dropdown>
 	);

frontend/src/components/ErrorModal/ErrorModal.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Modal, Tag } from 'antd';
-import { CircleAlert, X } from '@signozhq/icons';
+import { CircleAlert, X } from 'lucide-react';
 import KeyValueLabel from 'periscope/components/KeyValueLabel';
 import { useAppContext } from 'providers/App/App';
 import APIError from 'types/api/error';

frontend/src/components/ErrorModal/components/ErrorContent.tsx

@@ -3,7 +3,7 @@ import { Color } from '@signozhq/design-tokens';
 import { Button } from 'antd';
 import ErrorIcon from 'assets/Error';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
-import { BookOpenText, ChevronsDown } from '@signozhq/icons';
+import { BookOpenText, ChevronsDown } from 'lucide-react';
 import KeyValueLabel from 'periscope/components/KeyValueLabel';
 import APIError from 'types/api/error';
 

frontend/src/components/ExplorerCard/ExplorerCard.tsx

@@ -1,5 +1,11 @@
 import { useState } from 'react';
 import { useCopyToClipboard } from 'react-use';
+import {
+	DeleteOutlined,
+	MoreOutlined,
+	SaveOutlined,
+	ShareAltOutlined,
+} from '@ant-design/icons';
 import {
 	Button,
 	Col,
@@ -38,7 +44,6 @@ import {
 } from './styles';
 import { ExplorerCardProps } from './types';
 import { deleteViewHandler } from './utils';
-import { Ellipsis, Save, Share2, Trash2 } from '@signozhq/icons';
 
 function ExplorerCard({
 	sourcepage,
@@ -154,13 +159,13 @@ function ExplorerCard({
 				key: 'delete',
 				label: <Typography.Text strong>Delete</Typography.Text>,
 				onClick: onDeleteHandler,
-				icon: <Trash2 size="md" />,
+				icon: <DeleteOutlined />,
 			},
 		],
 	};
 
 	const saveButtonType = isQueryUpdated ? 'default' : 'primary';
-	const saveButtonIcon = isQueryUpdated ? null : <Save size="md" />;
+	const saveButtonIcon = isQueryUpdated ? null : <SaveOutlined />;
 
 	const showSaveView = false;
 
@@ -210,7 +215,11 @@ function ExplorerCard({
 									</Space>
 								)}
 								{isQueryUpdated && (
-									<Button type="primary" icon={<Save />} onClick={onUpdateQueryHandler}>
+									<Button
+										type="primary"
+										icon={<SaveOutlined />}
+										onClick={onUpdateQueryHandler}
+									>
 										Save changes
 									</Button>
 								)}
@@ -239,10 +248,10 @@ function ExplorerCard({
 											: SaveButtonText.SAVE_VIEW}
 									</Button>
 								</Popover>
-								<Share2 onClick={onCopyUrlHandler} size="md" />
+								<ShareAltOutlined onClick={onCopyUrlHandler} />
 								{viewKey && (
 									<Dropdown trigger={['click']} menu={moreOptionMenu}>
-										<Ellipsis size="md" />
+										<MoreOutlined />
 									</Dropdown>
 								)}
 							</Space>

frontend/src/components/ExplorerCard/MenuItemGenerator.tsx

@@ -1,5 +1,5 @@
 import { MouseEvent, useCallback } from 'react';
-import { Trash2 } from '@signozhq/icons';
+import { DeleteOutlined } from '@ant-design/icons';
 import { Col, Row, Tooltip } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
@@ -32,7 +32,7 @@ function MenuItemGenerator({
 
 	const { mutateAsync: deleteViewAsync } = useDeleteView(uuid);
 
-	const onDeleteHandler = (event: MouseEvent<SVGSVGElement>): void => {
+	const onDeleteHandler = (event: MouseEvent<HTMLElement>): void => {
 		event.stopPropagation();
 		deleteViewHandler({
 			deleteViewAsync,
@@ -87,12 +87,7 @@ function MenuItemGenerator({
 				</Col>
 				<Col span={2}>
 					<Typography.Link>
-						<Trash2
-							role="img"
-							aria-label="Delete view"
-							onClick={onDeleteHandler}
-							size="md"
-						/>
+						<DeleteOutlined onClick={onDeleteHandler} />
 					</Typography.Link>
 				</Col>
 			</Row>

frontend/src/components/ExplorerCard/test/MenuItemGenerator.test.tsx

@@ -55,7 +55,7 @@ describe('MenuItemGenerator', () => {
 		);
 
 		const spanElement = screen.getByRole('img', {
-			name: /delete view/i,
+			name: 'delete',
 		});
 
 		expect(spanElement).toBeInTheDocument();

frontend/src/components/HeaderRightSection/HeaderRightSection.tsx

@@ -3,7 +3,7 @@ import { useLocation } from 'react-router-dom';
 import { Button, Popover } from 'antd';
 import logEvent from 'api/common/logEvent';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { Globe, Inbox, SquarePen } from '@signozhq/icons';
+import { Globe, Inbox, SquarePen } from 'lucide-react';
 
 import AnnouncementsModal from './AnnouncementsModal';
 import FeedbackModal from './FeedbackModal';
@@ -105,7 +105,6 @@ function HeaderRightSection({
 					onOpenChange={handleOpenAnnouncementsModalChange}
 				>
 					<Button
-						aria-label="Announcements"
 						icon={<Inbox size={14} />}
 						className="periscope-btn ghost announcements-btn"
 						onClick={(): void => {

frontend/src/components/HeaderRightSection/ShareURLModal.tsx

@@ -11,7 +11,7 @@ import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import useUrlQuery from 'hooks/useUrlQuery';
 import GetMinMax from 'lib/getMinMax';
-import { Check, Info, Link2 } from '@signozhq/icons';
+import { Check, Info, Link2 } from 'lucide-react';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
 import { getAbsoluteUrl } from 'utils/basePath';

frontend/src/components/HeaderRightSection/__tests__/HeaderRightSection.test.tsx

@@ -80,10 +80,15 @@ describe('HeaderRightSection', () => {
 		expect(buttons).toHaveLength(3);
 		expect(screen.getByRole('button', { name: /share/i })).toBeInTheDocument();
 
-		expect(screen.getByRole('button', { name: /feedback/i })).toBeInTheDocument();
-		expect(
-			screen.getByRole('button', { name: /announcements/i }),
-		).toBeInTheDocument();
+		// Check for feedback button by class
+		const feedbackButton = document.querySelector(
+			'.share-feedback-btn[class*="share-feedback-btn"]',
+		);
+		expect(feedbackButton).toBeInTheDocument();
+
+		// Check for announcements button by finding the inbox icon
+		const inboxIcon = document.querySelector('.lucide-inbox');
+		expect(inboxIcon).toBeInTheDocument();
 	});
 
 	it('should render only enabled features', () => {
@@ -101,17 +106,22 @@ describe('HeaderRightSection', () => {
 			screen.queryByRole('button', { name: /share/i }),
 		).not.toBeInTheDocument();
 
-		expect(
-			screen.queryByRole('button', { name: /announcements/i }),
-		).not.toBeInTheDocument();
-		expect(screen.getByRole('button', { name: /feedback/i })).toBeInTheDocument();
+		// Check that inbox icon is not present
+		const inboxIcon = document.querySelector('.lucide-inbox');
+		expect(inboxIcon).not.toBeInTheDocument();
+
+		// Check that feedback button is present
+		const squarePenIcon = document.querySelector('.lucide-square-pen');
+		expect(squarePenIcon).toBeInTheDocument();
 	});
 
 	it('should open feedback modal and log event when feedback button is clicked', async () => {
 		const user = userEvent.setup();
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const feedbackButton = screen.getByRole('button', { name: /feedback/i });
+		const feedbackButton = document
+			.querySelector('.lucide-square-pen')
+			?.closest('button');
 		expect(feedbackButton).toBeInTheDocument();
 
 		await user.click(feedbackButton!);
@@ -139,9 +149,9 @@ describe('HeaderRightSection', () => {
 		const user = userEvent.setup();
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const announcementsButton = screen.getByRole('button', {
-			name: /announcements/i,
-		});
+		const announcementsButton = document
+			.querySelector('.lucide-inbox')
+			?.closest('button');
 		expect(announcementsButton).toBeInTheDocument();
 
 		await user.click(announcementsButton!);
@@ -156,7 +166,9 @@ describe('HeaderRightSection', () => {
 		render(<HeaderRightSection {...defaultProps} />);
 
 		// Open feedback modal
-		const feedbackButton = screen.getByRole('button', { name: /feedback/i });
+		const feedbackButton = document
+			.querySelector('.lucide-square-pen')
+			?.closest('button');
 		expect(feedbackButton).toBeInTheDocument();
 
 		await user.click(feedbackButton!);
@@ -178,7 +190,9 @@ describe('HeaderRightSection', () => {
 		expect(screen.getByTestId('share-modal')).toBeInTheDocument();
 
 		// Open feedback modal - should close share modal
-		const feedbackButton = screen.getByRole('button', { name: /feedback/i });
+		const feedbackButton = document
+			.querySelector('.lucide-square-pen')
+			?.closest('button');
 		expect(feedbackButton).toBeInTheDocument();
 
 		await user.click(feedbackButton!);
@@ -196,7 +210,7 @@ describe('HeaderRightSection', () => {
 
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const feedbackButton = screen.queryByRole('button', { name: /feedback/i });
+		const feedbackButton = document.querySelector('.lucide-square-pen');
 		expect(feedbackButton).toBeInTheDocument();
 	});
 
@@ -210,7 +224,7 @@ describe('HeaderRightSection', () => {
 
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const feedbackButton = screen.queryByRole('button', { name: /feedback/i });
+		const feedbackButton = document.querySelector('.lucide-square-pen');
 		expect(feedbackButton).toBeInTheDocument();
 	});
 
@@ -224,7 +238,7 @@ describe('HeaderRightSection', () => {
 
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const feedbackButton = screen.queryByRole('button', { name: /feedback/i });
+		const feedbackButton = document.querySelector('.lucide-square-pen');
 		expect(feedbackButton).not.toBeInTheDocument();
 	});
 
@@ -238,7 +252,7 @@ describe('HeaderRightSection', () => {
 
 		render(<HeaderRightSection {...defaultProps} />);
 
-		const feedbackButton = screen.queryByRole('button', { name: /feedback/i });
+		const feedbackButton = document.querySelector('.lucide-square-pen');
 		expect(feedbackButton).not.toBeInTheDocument();
 	});
 
@@ -258,13 +272,11 @@ describe('HeaderRightSection', () => {
 
 		// Verify which buttons are present
 		expect(screen.getByRole('button', { name: /share/i })).toBeInTheDocument();
-		expect(
-			screen.getByRole('button', { name: /announcements/i }),
-		).toBeInTheDocument();
+		const inboxIcon = document.querySelector('.lucide-inbox');
+		expect(inboxIcon).toBeInTheDocument();
 
 		// Verify feedback button is not present
-		expect(
-			screen.queryByRole('button', { name: /feedback/i }),
-		).not.toBeInTheDocument();
+		const feedbackIcon = document.querySelector('.lucide-square-pen');
+		expect(feedbackIcon).not.toBeInTheDocument();
 	});
 });

frontend/src/components/HostMetricsDetail/WaitlistFragment/WaitlistFragment.tsx

@@ -5,7 +5,7 @@ import { Button } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import { useNotifications } from 'hooks/useNotifications';
-import { CircleCheckBig, HandPlatter } from '@signozhq/icons';
+import { CheckCircle2, HandPlatter } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 
 import './WaitListFragment.styles.scss';
@@ -62,7 +62,7 @@ export default function WaitlistFragment({
 				loading={isSubmitting}
 				icon={
 					isSuccess ? (
-						<CircleCheckBig size={16} color={Color.BG_FOREST_500} />
+						<CheckCircle2 size={16} color={Color.BG_FOREST_500} />
 					) : (
 						<HandPlatter size={16} />
 					)

frontend/src/components/InputWithLabel/InputWithLabel.tsx

@@ -2,7 +2,7 @@ import { useState } from 'react';
 import { Button, Input } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
-import { X } from '@signozhq/icons';
+import { X } from 'lucide-react';
 
 import './InputWithLabel.styles.scss';
 

frontend/src/components/LaunchChatSupport/LaunchChatSupport.tsx

@@ -10,7 +10,7 @@ import { FeatureKeys } from 'constants/features';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 import { useNotifications } from 'hooks/useNotifications';
 import { defaultTo } from 'lodash-es';
-import { CircleHelp, CreditCard, X } from '@signozhq/icons';
+import { CreditCard, HelpCircle, X } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
 import { SuccessResponseV2 } from 'types/api';
 import { CheckoutSuccessPayloadProps } from 'types/api/billing/checkout';
@@ -170,7 +170,7 @@ function LaunchChatSupport({
 				<Button
 					className={cx('periscope-btn', 'facing-issue-button', className)}
 					onClick={handleFacingIssuesClick}
-					icon={<CircleHelp size={14} />}
+					icon={<HelpCircle size={14} />}
 				>
 					{buttonText || 'Facing issues?'}
 				</Button>

frontend/src/components/LearnMore/LearnMore.tsx

@@ -1,6 +1,6 @@
 import { Color } from '@signozhq/design-tokens';
 import { Button } from 'antd';
-import { ArrowUpRight } from '@signozhq/icons';
+import { ArrowUpRight } from 'lucide-react';
 import { openInNewTab } from 'utils/navigation';
 
 import './LearnMore.styles.scss';

frontend/src/components/LogDetail/index.tsx

@@ -36,17 +36,17 @@ import { cloneDeep } from 'lodash-es';
 import {
 	ArrowDown,
 	ArrowUp,
+	BarChart2,
 	Braces,
 	ChevronDown,
 	ChevronUp,
 	Compass,
 	Copy,
 	Filter,
-	Histogram,
 	Table,
 	TextSelect,
 	X,
-} from '@signozhq/icons';
+} from 'lucide-react';
 import { JsonView } from 'periscope/components/JsonView';
 import { useAppContext } from 'providers/App/App';
 import { AppState } from 'store/reducers';
@@ -228,7 +228,7 @@ function LogDetailInner({
 			}
 
 			return log?.body || '';
-		} catch {
+		} catch (error) {
 			return log?.body || '';
 		}
 	}, [isBodyJsonQueryEnabled, log?.body]);
@@ -499,7 +499,7 @@ function LogDetailInner({
 							value={VIEW_TYPES.INFRAMETRICS}
 						>
 							<div className="view-title">
-								<Histogram size="md" />
+								<BarChart2 size={14} />
 								Metrics
 							</div>
 						</Radio.Button>
@@ -517,7 +517,7 @@ function LogDetailInner({
 									variant="link"
 									color="secondary"
 									size="sm"
-									prefix={<Filter size="lg" />}
+									prefix={<Filter size={12} />}
 									onClick={handleFilterVisible}
 								/>
 							</Tooltip>