fix: lint issues

Merge remote-tracking branch 'origin/issue_4361' into issue_4361
Merge remote-tracking branch 'origin/main' into issue_4361
2026-04-21 03:10:27 +01:00 · 2026-04-20 16:09:50 +05:30 · 2026-04-20 16:09:35 +05:30 · 2026-04-20 16:09:12 +05:30 · 2026-04-20 16:09:09 +05:30 · 2026-04-20 11:02:57 +05:30
15 changed files with 2732 additions and 103 deletions
--- a/docs/api/openapi.yml
+++ b/docs/api/openapi.yml
@@ -4268,6 +4268,183 @@ components:
      type: object
    Sigv4SigV4Config:
      type: object
+    SpanattributemappingtypesCondition:
+      properties:
+        attributes:
+          items:
+            type: string
+          nullable: true
+          type: array
+        resource:
+          items:
+            type: string
+          nullable: true
+          type: array
+      type: object
+    SpanattributemappingtypesFieldContext:
+      enum:
+      - attribute
+      - resource
+      type: string
+    SpanattributemappingtypesGroup:
+      properties:
+        category:
+          type: string
+        condition:
+          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
+        createdAt:
+          format: date-time
+          type: string
+        createdBy:
+          type: string
+        enabled:
+          type: boolean
+        id:
+          type: string
+        name:
+          type: string
+        ordId:
+          type: string
+        updatedAt:
+          format: date-time
+          type: string
+        updatedBy:
+          type: string
+      required:
+      - id
+      - ordId
+      - name
+      - category
+      - condition
+      - enabled
+      type: object
+    SpanattributemappingtypesListGroupsResponse:
+      properties:
+        items:
+          items:
+            $ref: '#/components/schemas/SpanattributemappingtypesGroup'
+          nullable: true
+          type: array
+      required:
+      - items
+      type: object
+    SpanattributemappingtypesListMappersResponse:
+      properties:
+        items:
+          items:
+            $ref: '#/components/schemas/SpanattributemappingtypesMapper'
+          nullable: true
+          type: array
+      required:
+      - items
+      type: object
+    SpanattributemappingtypesMapper:
+      properties:
+        config:
+          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
+        createdAt:
+          format: date-time
+          type: string
+        createdBy:
+          type: string
+        enabled:
+          type: boolean
+        field_context:
+          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
+        group_id:
+          type: string
+        id:
+          type: string
+        name:
+          type: string
+        updatedAt:
+          format: date-time
+          type: string
+        updatedBy:
+          type: string
+      required:
+      - id
+      - group_id
+      - name
+      - field_context
+      - config
+      - enabled
+      type: object
+    SpanattributemappingtypesMapperConfig:
+      properties:
+        sources:
+          items:
+            $ref: '#/components/schemas/SpanattributemappingtypesMapperSource'
+          nullable: true
+          type: array
+      type: object
+    SpanattributemappingtypesMapperOperation:
+      enum:
+      - move
+      - copy
+      type: string
+    SpanattributemappingtypesMapperSource:
+      properties:
+        context:
+          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
+        key:
+          type: string
+        operation:
+          $ref: '#/components/schemas/SpanattributemappingtypesMapperOperation'
+        priority:
+          type: integer
+      type: object
+    SpanattributemappingtypesPostableGroup:
+      properties:
+        category:
+          type: string
+        condition:
+          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
+        enabled:
+          type: boolean
+        name:
+          type: string
+      required:
+      - name
+      - category
+      - condition
+      type: object
+    SpanattributemappingtypesPostableMapper:
+      properties:
+        config:
+          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
+        enabled:
+          type: boolean
+        field_context:
+          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
+        name:
+          type: string
+      required:
+      - name
+      - field_context
+      - config
+      type: object
+    SpanattributemappingtypesUpdatableGroup:
+      properties:
+        condition:
+          $ref: '#/components/schemas/SpanattributemappingtypesCondition'
+        enabled:
+          nullable: true
+          type: boolean
+        name:
+          nullable: true
+          type: string
+      type: object
+    SpanattributemappingtypesUpdatableMapper:
+      properties:
+        config:
+          $ref: '#/components/schemas/SpanattributemappingtypesMapperConfig'
+        enabled:
+          nullable: true
+          type: boolean
+        field_context:
+          $ref: '#/components/schemas/SpanattributemappingtypesFieldContext'
+      type: object
    TelemetrytypesFieldContext:
      enum:
      - metric
@@ -8876,6 +9053,510 @@ paths:
      summary: Updates my service account
      tags:
      - serviceaccount
+  /api/v1/span_attribute_mapping_groups:
+    get:
+      deprecated: false
+      description: Returns all span attribute mapping groups for the authenticated
+        org.
+      operationId: ListSpanAttributeMappingGroups
+      parameters:
+      - in: query
+        name: category
+        schema:
+          nullable: true
+          type: string
+      - in: query
+        name: enabled
+        schema:
+          nullable: true
+          type: boolean
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesListGroupsResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List span attribute mapping groups
+      tags:
+      - span-attribute-mapping
+    post:
+      deprecated: false
+      description: Creates a new span attribute mapping group for the org.
+      operationId: CreateMappingGroup
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SpanattributemappingtypesPostableGroup'
+      responses:
+        "201":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesGroup'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "409":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Conflict
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Create a span attribute mapping group
+      tags:
+      - span-attribute-mapping
+  /api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}:
+    delete:
+      deprecated: false
+      description: Hard-deletes a mapper from a mapping group.
+      operationId: DeleteMapper
+      parameters:
+      - in: path
+        name: groupId
+        required: true
+        schema:
+          type: string
+      - in: path
+        name: mapperId
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Delete a span attribute mapper
+      tags:
+      - span-attribute-mapping
+    patch:
+      deprecated: false
+      description: Partially updates an existing mapper's field context, config, or
+        enabled state.
+      operationId: UpdateMapper
+      parameters:
+      - in: path
+        name: groupId
+        required: true
+        schema:
+          type: string
+      - in: path
+        name: mapperId
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SpanattributemappingtypesUpdatableMapper'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesMapper'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Update a span attribute mapper
+      tags:
+      - span-attribute-mapping
+  /api/v1/span_attribute_mapping_groups/{id}:
+    delete:
+      deprecated: false
+      description: Hard-deletes a mapping group and cascades to all its mappers.
+      operationId: DeleteMappingGroup
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "204":
+          description: No Content
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Delete a span attribute mapping group
+      tags:
+      - span-attribute-mapping
+    patch:
+      deprecated: false
+      description: Partially updates an existing mapping group's name, condition,
+        or enabled state.
+      operationId: UpdateMappingGroup
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SpanattributemappingtypesUpdatableGroup'
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesGroup'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Update a span attribute mapping group
+      tags:
+      - span-attribute-mapping
+  /api/v1/span_attribute_mapping_groups/{id}/mappers:
+    get:
+      deprecated: false
+      description: Returns all attribute mappers belonging to a mapping group.
+      operationId: ListMappers
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesListMappersResponse'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: List span attribute mappers for a group
+      tags:
+      - span-attribute-mapping
+    post:
+      deprecated: false
+      description: Adds a new attribute mapper to the specified mapping group.
+      operationId: CreateMapper
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/SpanattributemappingtypesPostableMapper'
+      responses:
+        "201":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpanattributemappingtypesMapper'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: Created
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "409":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Conflict
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Create a span attribute mapper
+      tags:
+      - span-attribute-mapping
  /api/v1/testChannel:
    post:
      deprecated: true
--- a/frontend/src/api/generated/services/sigNoz.schemas.ts
+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts
@@ -5243,6 +5243,198 @@ export interface Sigv4SigV4ConfigDTO {
 	[key: string]: unknown;
 }

+export interface SpanattributemappingtypesConditionDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	attributes?: string[] | null;
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	resource?: string[] | null;
+}
+
+export enum SpanattributemappingtypesFieldContextDTO {
+	attribute = 'attribute',
+	resource = 'resource',
+}
+export interface SpanattributemappingtypesGroupDTO {
+	/**
+	 * @type string
+	 */
+	category: string;
+	condition: SpanattributemappingtypesConditionDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type boolean
+	 */
+	enabled: boolean;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	name: string;
+	/**
+	 * @type string
+	 */
+	ordId: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+}
+
+export interface SpanattributemappingtypesListGroupsResponseDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	items: SpanattributemappingtypesGroupDTO[] | null;
+}
+
+export interface SpanattributemappingtypesListMappersResponseDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	items: SpanattributemappingtypesMapperDTO[] | null;
+}
+
+export interface SpanattributemappingtypesMapperDTO {
+	config: SpanattributemappingtypesMapperConfigDTO;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	createdAt?: Date;
+	/**
+	 * @type string
+	 */
+	createdBy?: string;
+	/**
+	 * @type boolean
+	 */
+	enabled: boolean;
+	field_context: SpanattributemappingtypesFieldContextDTO;
+	/**
+	 * @type string
+	 */
+	group_id: string;
+	/**
+	 * @type string
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	name: string;
+	/**
+	 * @type string
+	 * @format date-time
+	 */
+	updatedAt?: Date;
+	/**
+	 * @type string
+	 */
+	updatedBy?: string;
+}
+
+export interface SpanattributemappingtypesMapperConfigDTO {
+	/**
+	 * @type array
+	 * @nullable true
+	 */
+	sources?: SpanattributemappingtypesMapperSourceDTO[] | null;
+}
+
+export enum SpanattributemappingtypesMapperOperationDTO {
+	move = 'move',
+	copy = 'copy',
+}
+export interface SpanattributemappingtypesMapperSourceDTO {
+	context?: SpanattributemappingtypesFieldContextDTO;
+	/**
+	 * @type string
+	 */
+	key?: string;
+	operation?: SpanattributemappingtypesMapperOperationDTO;
+	/**
+	 * @type integer
+	 */
+	priority?: number;
+}
+
+export interface SpanattributemappingtypesPostableGroupDTO {
+	/**
+	 * @type string
+	 */
+	category: string;
+	condition: SpanattributemappingtypesConditionDTO;
+	/**
+	 * @type boolean
+	 */
+	enabled?: boolean;
+	/**
+	 * @type string
+	 */
+	name: string;
+}
+
+export interface SpanattributemappingtypesPostableMapperDTO {
+	config: SpanattributemappingtypesMapperConfigDTO;
+	/**
+	 * @type boolean
+	 */
+	enabled?: boolean;
+	field_context: SpanattributemappingtypesFieldContextDTO;
+	/**
+	 * @type string
+	 */
+	name: string;
+}
+
+export interface SpanattributemappingtypesUpdatableGroupDTO {
+	condition?: SpanattributemappingtypesConditionDTO;
+	/**
+	 * @type boolean
+	 * @nullable true
+	 */
+	enabled?: boolean | null;
+	/**
+	 * @type string
+	 * @nullable true
+	 */
+	name?: string | null;
+}
+
+export interface SpanattributemappingtypesUpdatableMapperDTO {
+	config?: SpanattributemappingtypesMapperConfigDTO;
+	/**
+	 * @type boolean
+	 * @nullable true
+	 */
+	enabled?: boolean | null;
+	field_context?: SpanattributemappingtypesFieldContextDTO;
+}
+
 export enum TelemetrytypesFieldContextDTO {
 	metric = 'metric',
 	log = 'log',
@@ -6462,6 +6654,89 @@ export type GetMyServiceAccount200 = {
 	status: string;
 };

+export type ListSpanAttributeMappingGroupsParams = {
+	/**
+	 * @type string
+	 * @nullable true
+	 * @description undefined
+	 */
+	category?: string | null;
+	/**
+	 * @type boolean
+	 * @nullable true
+	 * @description undefined
+	 */
+	enabled?: boolean | null;
+};
+
+export type ListSpanAttributeMappingGroups200 = {
+	data: SpanattributemappingtypesListGroupsResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type CreateMappingGroup201 = {
+	data: SpanattributemappingtypesGroupDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type DeleteMapperPathParameters = {
+	groupId: string;
+	mapperId: string;
+};
+export type UpdateMapperPathParameters = {
+	groupId: string;
+	mapperId: string;
+};
+export type UpdateMapper200 = {
+	data: SpanattributemappingtypesMapperDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type DeleteMappingGroupPathParameters = {
+	id: string;
+};
+export type UpdateMappingGroupPathParameters = {
+	id: string;
+};
+export type UpdateMappingGroup200 = {
+	data: SpanattributemappingtypesGroupDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type ListMappersPathParameters = {
+	id: string;
+};
+export type ListMappers200 = {
+	data: SpanattributemappingtypesListMappersResponseDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
+export type CreateMapperPathParameters = {
+	id: string;
+};
+export type CreateMapper201 = {
+	data: SpanattributemappingtypesMapperDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type ListUsersDeprecated200 = {
 	/**
 	 * @type array
--- a/frontend/src/api/generated/services/span-attribute-mapping/index.ts
+++ b/frontend/src/api/generated/services/span-attribute-mapping/index.ts
@@ -0,0 +1,784 @@
+/**
+ * ! Do not edit manually
+ * * The file has been auto-generated using Orval for SigNoz
+ * * regenerate with 'yarn generate:api'
+ * SigNoz
+ */
+import type {
+	InvalidateOptions,
+	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
+	UseMutationOptions,
+	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
+} from 'react-query';
+import { useMutation, useQuery } from 'react-query';
+
+import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
+import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
+import type {
+	CreateMapper201,
+	CreateMapperPathParameters,
+	CreateMappingGroup201,
+	DeleteMapperPathParameters,
+	DeleteMappingGroupPathParameters,
+	ListMappers200,
+	ListMappersPathParameters,
+	ListSpanAttributeMappingGroups200,
+	ListSpanAttributeMappingGroupsParams,
+	RenderErrorResponseDTO,
+	SpanattributemappingtypesPostableGroupDTO,
+	SpanattributemappingtypesPostableMapperDTO,
+	SpanattributemappingtypesUpdatableGroupDTO,
+	SpanattributemappingtypesUpdatableMapperDTO,
+	UpdateMapper200,
+	UpdateMapperPathParameters,
+	UpdateMappingGroup200,
+	UpdateMappingGroupPathParameters,
+} from '../sigNoz.schemas';
+
+/**
+ * Returns all span attribute mapping groups for the authenticated org.
+ * @summary List span attribute mapping groups
+ */
+export const listSpanAttributeMappingGroups = (
+	params?: ListSpanAttributeMappingGroupsParams,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListSpanAttributeMappingGroups200>({
+		url: `/api/v1/span_attribute_mapping_groups`,
+		method: 'GET',
+		params,
+		signal,
+	});
+};
+
+export const getListSpanAttributeMappingGroupsQueryKey = (
+	params?: ListSpanAttributeMappingGroupsParams,
+) => {
+	return [
+		`/api/v1/span_attribute_mapping_groups`,
+		...(params ? [params] : []),
+	] as const;
+};
+
+export const getListSpanAttributeMappingGroupsQueryOptions = <
+	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	params?: ListSpanAttributeMappingGroupsParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getListSpanAttributeMappingGroupsQueryKey(params);
+
+	const queryFn: QueryFunction<
+		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
+	> = ({ signal }) => listSpanAttributeMappingGroups(params, signal);
+
+	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
+		Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListSpanAttributeMappingGroupsQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>
+>;
+export type ListSpanAttributeMappingGroupsQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List span attribute mapping groups
+ */
+
+export function useListSpanAttributeMappingGroups<
+	TData = Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	params?: ListSpanAttributeMappingGroupsParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listSpanAttributeMappingGroups>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListSpanAttributeMappingGroupsQueryOptions(
+		params,
+		options,
+	);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List span attribute mapping groups
+ */
+export const invalidateListSpanAttributeMappingGroups = async (
+	queryClient: QueryClient,
+	params?: ListSpanAttributeMappingGroupsParams,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListSpanAttributeMappingGroupsQueryKey(params) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * Creates a new span attribute mapping group for the org.
+ * @summary Create a span attribute mapping group
+ */
+export const createMappingGroup = (
+	spanattributemappingtypesPostableGroupDTO: BodyType<SpanattributemappingtypesPostableGroupDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateMappingGroup201>({
+		url: `/api/v1/span_attribute_mapping_groups`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: spanattributemappingtypesPostableGroupDTO,
+		signal,
+	});
+};
+
+export const getCreateMappingGroupMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createMappingGroup>>,
+		TError,
+		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createMappingGroup>>,
+	TError,
+	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
+	TContext
+> => {
+	const mutationKey = ['createMappingGroup'];
+	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 createMappingGroup>>,
+		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> }
+	> = (props) => {
+		const { data } = props ?? {};
+
+		return createMappingGroup(data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateMappingGroupMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createMappingGroup>>
+>;
+export type CreateMappingGroupMutationBody = BodyType<SpanattributemappingtypesPostableGroupDTO>;
+export type CreateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create a span attribute mapping group
+ */
+export const useCreateMappingGroup = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createMappingGroup>>,
+		TError,
+		{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createMappingGroup>>,
+	TError,
+	{ data: BodyType<SpanattributemappingtypesPostableGroupDTO> },
+	TContext
+> => {
+	const mutationOptions = getCreateMappingGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Hard-deletes a mapper from a mapping group.
+ * @summary Delete a span attribute mapper
+ */
+export const deleteMapper = ({
+	groupId,
+	mapperId,
+}: DeleteMapperPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteMapperMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteMapper>>,
+		TError,
+		{ pathParams: DeleteMapperPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteMapper>>,
+	TError,
+	{ pathParams: DeleteMapperPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteMapper'];
+	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 deleteMapper>>,
+		{ pathParams: DeleteMapperPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteMapper(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteMapperMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteMapper>>
+>;
+
+export type DeleteMapperMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete a span attribute mapper
+ */
+export const useDeleteMapper = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteMapper>>,
+		TError,
+		{ pathParams: DeleteMapperPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteMapper>>,
+	TError,
+	{ pathParams: DeleteMapperPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Partially updates an existing mapper's field context, config, or enabled state.
+ * @summary Update a span attribute mapper
+ */
+export const updateMapper = (
+	{ groupId, mapperId }: UpdateMapperPathParameters,
+	spanattributemappingtypesUpdatableMapperDTO: BodyType<SpanattributemappingtypesUpdatableMapperDTO>,
+) => {
+	return GeneratedAPIInstance<UpdateMapper200>({
+		url: `/api/v1/span_attribute_mapping_groups/${groupId}/mappers/${mapperId}`,
+		method: 'PATCH',
+		headers: { 'Content-Type': 'application/json' },
+		data: spanattributemappingtypesUpdatableMapperDTO,
+	});
+};
+
+export const getUpdateMapperMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateMapper>>,
+		TError,
+		{
+			pathParams: UpdateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateMapper>>,
+	TError,
+	{
+		pathParams: UpdateMapperPathParameters;
+		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateMapper'];
+	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 updateMapper>>,
+		{
+			pathParams: UpdateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateMapper(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateMapperMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateMapper>>
+>;
+export type UpdateMapperMutationBody = BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+export type UpdateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update a span attribute mapper
+ */
+export const useUpdateMapper = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateMapper>>,
+		TError,
+		{
+			pathParams: UpdateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateMapper>>,
+	TError,
+	{
+		pathParams: UpdateMapperPathParameters;
+		data: BodyType<SpanattributemappingtypesUpdatableMapperDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Hard-deletes a mapping group and cascades to all its mappers.
+ * @summary Delete a span attribute mapping group
+ */
+export const deleteMappingGroup = ({
+	id,
+}: DeleteMappingGroupPathParameters) => {
+	return GeneratedAPIInstance<void>({
+		url: `/api/v1/span_attribute_mapping_groups/${id}`,
+		method: 'DELETE',
+	});
+};
+
+export const getDeleteMappingGroupMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteMappingGroup>>,
+		TError,
+		{ pathParams: DeleteMappingGroupPathParameters },
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof deleteMappingGroup>>,
+	TError,
+	{ pathParams: DeleteMappingGroupPathParameters },
+	TContext
+> => {
+	const mutationKey = ['deleteMappingGroup'];
+	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 deleteMappingGroup>>,
+		{ pathParams: DeleteMappingGroupPathParameters }
+	> = (props) => {
+		const { pathParams } = props ?? {};
+
+		return deleteMappingGroup(pathParams);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type DeleteMappingGroupMutationResult = NonNullable<
+	Awaited<ReturnType<typeof deleteMappingGroup>>
+>;
+
+export type DeleteMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Delete a span attribute mapping group
+ */
+export const useDeleteMappingGroup = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof deleteMappingGroup>>,
+		TError,
+		{ pathParams: DeleteMappingGroupPathParameters },
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof deleteMappingGroup>>,
+	TError,
+	{ pathParams: DeleteMappingGroupPathParameters },
+	TContext
+> => {
+	const mutationOptions = getDeleteMappingGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Partially updates an existing mapping group's name, condition, or enabled state.
+ * @summary Update a span attribute mapping group
+ */
+export const updateMappingGroup = (
+	{ id }: UpdateMappingGroupPathParameters,
+	spanattributemappingtypesUpdatableGroupDTO: BodyType<SpanattributemappingtypesUpdatableGroupDTO>,
+) => {
+	return GeneratedAPIInstance<UpdateMappingGroup200>({
+		url: `/api/v1/span_attribute_mapping_groups/${id}`,
+		method: 'PATCH',
+		headers: { 'Content-Type': 'application/json' },
+		data: spanattributemappingtypesUpdatableGroupDTO,
+	});
+};
+
+export const getUpdateMappingGroupMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateMappingGroup>>,
+		TError,
+		{
+			pathParams: UpdateMappingGroupPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof updateMappingGroup>>,
+	TError,
+	{
+		pathParams: UpdateMappingGroupPathParameters;
+		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['updateMappingGroup'];
+	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 updateMappingGroup>>,
+		{
+			pathParams: UpdateMappingGroupPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return updateMappingGroup(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type UpdateMappingGroupMutationResult = NonNullable<
+	Awaited<ReturnType<typeof updateMappingGroup>>
+>;
+export type UpdateMappingGroupMutationBody = BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+export type UpdateMappingGroupMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Update a span attribute mapping group
+ */
+export const useUpdateMappingGroup = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof updateMappingGroup>>,
+		TError,
+		{
+			pathParams: UpdateMappingGroupPathParameters;
+			data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof updateMappingGroup>>,
+	TError,
+	{
+		pathParams: UpdateMappingGroupPathParameters;
+		data: BodyType<SpanattributemappingtypesUpdatableGroupDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getUpdateMappingGroupMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
+/**
+ * Returns all attribute mappers belonging to a mapping group.
+ * @summary List span attribute mappers for a group
+ */
+export const listMappers = (
+	{ id }: ListMappersPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<ListMappers200>({
+		url: `/api/v1/span_attribute_mapping_groups/${id}/mappers`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getListMappersQueryKey = ({ id }: ListMappersPathParameters) => {
+	return [`/api/v1/span_attribute_mapping_groups/${id}/mappers`] as const;
+};
+
+export const getListMappersQueryOptions = <
+	TData = Awaited<ReturnType<typeof listMappers>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: ListMappersPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listMappers>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getListMappersQueryKey({ id });
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof listMappers>>> = ({
+		signal,
+	}) => listMappers({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof listMappers>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type ListMappersQueryResult = NonNullable<
+	Awaited<ReturnType<typeof listMappers>>
+>;
+export type ListMappersQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary List span attribute mappers for a group
+ */
+
+export function useListMappers<
+	TData = Awaited<ReturnType<typeof listMappers>>,
+	TError = ErrorType<RenderErrorResponseDTO>
+>(
+	{ id }: ListMappersPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof listMappers>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getListMappersQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary List span attribute mappers for a group
+ */
+export const invalidateListMappers = async (
+	queryClient: QueryClient,
+	{ id }: ListMappersPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getListMappersQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
+/**
+ * Adds a new attribute mapper to the specified mapping group.
+ * @summary Create a span attribute mapper
+ */
+export const createMapper = (
+	{ id }: CreateMapperPathParameters,
+	spanattributemappingtypesPostableMapperDTO: BodyType<SpanattributemappingtypesPostableMapperDTO>,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<CreateMapper201>({
+		url: `/api/v1/span_attribute_mapping_groups/${id}/mappers`,
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		data: spanattributemappingtypesPostableMapperDTO,
+		signal,
+	});
+};
+
+export const getCreateMapperMutationOptions = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createMapper>>,
+		TError,
+		{
+			pathParams: CreateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
+		},
+		TContext
+	>;
+}): UseMutationOptions<
+	Awaited<ReturnType<typeof createMapper>>,
+	TError,
+	{
+		pathParams: CreateMapperPathParameters;
+		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
+	},
+	TContext
+> => {
+	const mutationKey = ['createMapper'];
+	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 createMapper>>,
+		{
+			pathParams: CreateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
+		}
+	> = (props) => {
+		const { pathParams, data } = props ?? {};
+
+		return createMapper(pathParams, data);
+	};
+
+	return { mutationFn, ...mutationOptions };
+};
+
+export type CreateMapperMutationResult = NonNullable<
+	Awaited<ReturnType<typeof createMapper>>
+>;
+export type CreateMapperMutationBody = BodyType<SpanattributemappingtypesPostableMapperDTO>;
+export type CreateMapperMutationError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Create a span attribute mapper
+ */
+export const useCreateMapper = <
+	TError = ErrorType<RenderErrorResponseDTO>,
+	TContext = unknown
+>(options?: {
+	mutation?: UseMutationOptions<
+		Awaited<ReturnType<typeof createMapper>>,
+		TError,
+		{
+			pathParams: CreateMapperPathParameters;
+			data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
+		},
+		TContext
+	>;
+}): UseMutationResult<
+	Awaited<ReturnType<typeof createMapper>>,
+	TError,
+	{
+		pathParams: CreateMapperPathParameters;
+		data: BodyType<SpanattributemappingtypesPostableMapperDTO>;
+	},
+	TContext
+> => {
+	const mutationOptions = getCreateMapperMutationOptions(options);
+
+	return useMutation(mutationOptions);
+};
--- a/pkg/apiserver/signozapiserver/provider.go
+++ b/pkg/apiserver/signozapiserver/provider.go
@@ -24,6 +24,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
+	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -34,33 +35,34 @@ import (
 )

 type provider struct {
-	config                  apiserver.Config
-	settings                factory.ScopedProviderSettings
-	router                  *mux.Router
-	authZ                   *middleware.AuthZ
-	orgHandler              organization.Handler
-	userHandler             user.Handler
-	sessionHandler          session.Handler
-	authDomainHandler       authdomain.Handler
-	preferenceHandler       preference.Handler
-	globalHandler           global.Handler
-	promoteHandler          promote.Handler
-	flaggerHandler          flagger.Handler
-	dashboardModule         dashboard.Module
-	dashboardHandler        dashboard.Handler
-	metricsExplorerHandler  metricsexplorer.Handler
-	gatewayHandler          gateway.Handler
-	fieldsHandler           fields.Handler
-	authzHandler            authz.Handler
-	rawDataExportHandler    rawdataexport.Handler
-	zeusHandler             zeus.Handler
-	querierHandler          querier.Handler
-	serviceAccountHandler   serviceaccount.Handler
-	factoryHandler          factory.Handler
-	cloudIntegrationHandler cloudintegration.Handler
-	ruleStateHistoryHandler rulestatehistory.Handler
-	alertmanagerHandler     alertmanager.Handler
-	rulerHandler            ruler.Handler
+	config                      apiserver.Config
+	settings                    factory.ScopedProviderSettings
+	router                      *mux.Router
+	authZ                       *middleware.AuthZ
+	orgHandler                  organization.Handler
+	userHandler                 user.Handler
+	sessionHandler              session.Handler
+	authDomainHandler           authdomain.Handler
+	preferenceHandler           preference.Handler
+	globalHandler               global.Handler
+	promoteHandler              promote.Handler
+	flaggerHandler              flagger.Handler
+	dashboardModule             dashboard.Module
+	dashboardHandler            dashboard.Handler
+	metricsExplorerHandler      metricsexplorer.Handler
+	gatewayHandler              gateway.Handler
+	fieldsHandler               fields.Handler
+	authzHandler                authz.Handler
+	rawDataExportHandler        rawdataexport.Handler
+	zeusHandler                 zeus.Handler
+	querierHandler              querier.Handler
+	serviceAccountHandler       serviceaccount.Handler
+	factoryHandler              factory.Handler
+	cloudIntegrationHandler     cloudintegration.Handler
+	ruleStateHistoryHandler     rulestatehistory.Handler
+	spanAttributeMappingHandler spanattributemapping.Handler
+	alertmanagerHandler         alertmanager.Handler
+	rulerHandler                ruler.Handler
 }

 func NewFactory(
@@ -87,6 +89,7 @@ func NewFactory(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
+	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
@@ -118,6 +121,7 @@ func NewFactory(
 			factoryHandler,
 			cloudIntegrationHandler,
 			ruleStateHistoryHandler,
+			spanAttributeMappingHandler,
 			alertmanagerHandler,
 			rulerHandler,
 		)
@@ -151,6 +155,7 @@ func newProvider(
 	factoryHandler factory.Handler,
 	cloudIntegrationHandler cloudintegration.Handler,
 	ruleStateHistoryHandler rulestatehistory.Handler,
+	spanAttributeMappingHandler spanattributemapping.Handler,
 	alertmanagerHandler alertmanager.Handler,
 	rulerHandler ruler.Handler,
 ) (apiserver.APIServer, error) {
@@ -158,32 +163,33 @@ func newProvider(
 	router := mux.NewRouter().UseEncodedPath()

 	provider := &provider{
-		config:                  config,
-		settings:                settings,
-		router:                  router,
-		orgHandler:              orgHandler,
-		userHandler:             userHandler,
-		sessionHandler:          sessionHandler,
-		authDomainHandler:       authDomainHandler,
-		preferenceHandler:       preferenceHandler,
-		globalHandler:           globalHandler,
-		promoteHandler:          promoteHandler,
-		flaggerHandler:          flaggerHandler,
-		dashboardModule:         dashboardModule,
-		dashboardHandler:        dashboardHandler,
-		metricsExplorerHandler:  metricsExplorerHandler,
-		gatewayHandler:          gatewayHandler,
-		fieldsHandler:           fieldsHandler,
-		authzHandler:            authzHandler,
-		rawDataExportHandler:    rawDataExportHandler,
-		zeusHandler:             zeusHandler,
-		querierHandler:          querierHandler,
-		serviceAccountHandler:   serviceAccountHandler,
-		factoryHandler:          factoryHandler,
-		cloudIntegrationHandler: cloudIntegrationHandler,
-		ruleStateHistoryHandler: ruleStateHistoryHandler,
-		alertmanagerHandler:     alertmanagerHandler,
-		rulerHandler:            rulerHandler,
+		config:                      config,
+		settings:                    settings,
+		router:                      router,
+		orgHandler:                  orgHandler,
+		userHandler:                 userHandler,
+		sessionHandler:              sessionHandler,
+		authDomainHandler:           authDomainHandler,
+		preferenceHandler:           preferenceHandler,
+		globalHandler:               globalHandler,
+		promoteHandler:              promoteHandler,
+		flaggerHandler:              flaggerHandler,
+		dashboardModule:             dashboardModule,
+		dashboardHandler:            dashboardHandler,
+		metricsExplorerHandler:      metricsExplorerHandler,
+		gatewayHandler:              gatewayHandler,
+		fieldsHandler:               fieldsHandler,
+		authzHandler:                authzHandler,
+		rawDataExportHandler:        rawDataExportHandler,
+		zeusHandler:                 zeusHandler,
+		querierHandler:              querierHandler,
+		serviceAccountHandler:       serviceAccountHandler,
+		factoryHandler:              factoryHandler,
+		cloudIntegrationHandler:     cloudIntegrationHandler,
+		ruleStateHistoryHandler:     ruleStateHistoryHandler,
+		spanAttributeMappingHandler: spanAttributeMappingHandler,
+		alertmanagerHandler:         alertmanagerHandler,
+		rulerHandler:                rulerHandler,
 	}

 	provider.authZ = middleware.NewAuthZ(settings.Logger(), orgGetter, authz)
@@ -284,6 +290,10 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}

+	if err := provider.addSpanAttributeMappingRoutes(router); err != nil {
+		return err
+	}
+
 	if err := provider.addAlertmanagerRoutes(router); err != nil {
 		return err
 	}
--- a/pkg/apiserver/signozapiserver/spanattributemapping.go
+++ b/pkg/apiserver/signozapiserver/spanattributemapping.go
@@ -0,0 +1,175 @@
+package signozapiserver
+
+import (
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/http/handler"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
+	"github.com/gorilla/mux"
+)
+
+func (provider *provider) addSpanAttributeMappingRoutes(router *mux.Router) error {
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups", handler.New(
+		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListGroups),
+		handler.OpenAPIDef{
+			ID:                  "ListSpanAttributeMappingGroups",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "List span attribute mapping groups",
+			Description:         "Returns all span attribute mapping groups for the authenticated org.",
+			Request:             nil,
+			RequestContentType:  "",
+			RequestQuery:        new(spanattributemappingtypes.ListGroupsQuery),
+			Response:            new(spanattributemappingtypes.ListGroupsResponse),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateGroup),
+		handler.OpenAPIDef{
+			ID:                  "CreateMappingGroup",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Create a span attribute mapping group",
+			Description:         "Creates a new span attribute mapping group for the org.",
+			Request:             new(spanattributemappingtypes.PostableGroup),
+			RequestContentType:  "application/json",
+			Response:            new(spanattributemappingtypes.GettableGroup),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusCreated,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusConflict},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{id}", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateGroup),
+		handler.OpenAPIDef{
+			ID:                  "UpdateMappingGroup",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Update a span attribute mapping group",
+			Description:         "Partially updates an existing mapping group's name, condition, or enabled state.",
+			Request:             new(spanattributemappingtypes.UpdatableGroup),
+			RequestContentType:  "application/json",
+			Response:            new(spanattributemappingtypes.GettableGroup),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodPatch).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{id}", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteGroup),
+		handler.OpenAPIDef{
+			ID:                  "DeleteMappingGroup",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Delete a span attribute mapping group",
+			Description:         "Hard-deletes a mapping group and cascades to all its mappers.",
+			Request:             nil,
+			RequestContentType:  "",
+			Response:            nil,
+			ResponseContentType: "",
+			SuccessStatusCode:   http.StatusNoContent,
+			ErrorStatusCodes:    []int{http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{id}/mappers", handler.New(
+		provider.authZ.ViewAccess(provider.spanAttributeMappingHandler.ListMappers),
+		handler.OpenAPIDef{
+			ID:                  "ListMappers",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "List span attribute mappers for a group",
+			Description:         "Returns all attribute mappers belonging to a mapping group.",
+			Request:             nil,
+			RequestContentType:  "",
+			Response:            new(spanattributemappingtypes.ListMappersResponse),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{id}/mappers", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.CreateMapper),
+		handler.OpenAPIDef{
+			ID:                  "CreateMapper",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Create a span attribute mapper",
+			Description:         "Adds a new attribute mapper to the specified mapping group.",
+			Request:             new(spanattributemappingtypes.PostableMapper),
+			RequestContentType:  "application/json",
+			Response:            new(spanattributemappingtypes.GettableMapper),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusCreated,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound, http.StatusConflict},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodPost).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.UpdateMapper),
+		handler.OpenAPIDef{
+			ID:                  "UpdateMapper",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Update a span attribute mapper",
+			Description:         "Partially updates an existing mapper's field context, config, or enabled state.",
+			Request:             new(spanattributemappingtypes.UpdatableMapper),
+			RequestContentType:  "application/json",
+			Response:            new(spanattributemappingtypes.GettableMapper),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodPatch).GetError(); err != nil {
+		return err
+	}
+
+	if err := router.Handle("/api/v1/span_attribute_mapping_groups/{groupId}/mappers/{mapperId}", handler.New(
+		provider.authZ.AdminAccess(provider.spanAttributeMappingHandler.DeleteMapper),
+		handler.OpenAPIDef{
+			ID:                  "DeleteMapper",
+			Tags:                []string{"span-attribute-mapping"},
+			Summary:             "Delete a span attribute mapper",
+			Description:         "Hard-deletes a mapper from a mapping group.",
+			Request:             nil,
+			RequestContentType:  "",
+			Response:            nil,
+			ResponseContentType: "",
+			SuccessStatusCode:   http.StatusNoContent,
+			ErrorStatusCodes:    []int{http.StatusNotFound},
+			Deprecated:          false,
+			SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
+		},
+	)).Methods(http.MethodDelete).GetError(); err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/pkg/modules/spanattributemapping/implspanattributemapping/handler.go
+++ b/pkg/modules/spanattributemapping/implspanattributemapping/handler.go
@@ -0,0 +1,350 @@
+package implspanattributemapping
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/http/binding"
+	"github.com/SigNoz/signoz/pkg/http/render"
+	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/gorilla/mux"
+)
+
+type handler struct {
+	module           spanattributemapping.Module
+	providerSettings factory.ProviderSettings
+}
+
+func NewHandler(module spanattributemapping.Module, providerSettings factory.ProviderSettings) spanattributemapping.Handler {
+	return &handler{module: module, providerSettings: providerSettings}
+}
+
+// ListGroups handles GET /api/v1/ai-o11y/mapping/groups.
+func (h *handler) ListGroups(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	var q spanattributemappingtypes.ListGroupsQuery
+	if err := binding.Query.BindQuery(r.URL.Query(), &q); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groups, err := h.module.ListGroups(ctx, orgID, &q)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	items := make([]*spanattributemappingtypes.GettableGroup, len(groups))
+	for i, g := range groups {
+		items[i] = spanattributemappingtypes.NewGettableGroup(g)
+	}
+
+	render.Success(rw, http.StatusOK, &spanattributemappingtypes.ListGroupsResponse{Items: items})
+}
+
+// CreateGroup handles POST /api/v1/ai-o11y/mapping/groups.
+func (h *handler) CreateGroup(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(spanattributemappingtypes.PostableGroup)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	group, err := h.module.CreateGroup(ctx, orgID, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, spanattributemappingtypes.NewGettableGroup(group))
+}
+
+// UpdateGroup handles PUT /api/v1/ai-o11y/mapping/groups/{id}.
+func (h *handler) UpdateGroup(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(spanattributemappingtypes.UpdatableGroup)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	group, err := h.module.UpdateGroup(ctx, orgID, id, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableGroup(group))
+}
+
+// DeleteGroup handles DELETE /api/v1/ai-o11y/mapping/groups/{id}.
+func (h *handler) DeleteGroup(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := h.module.DeleteGroup(ctx, orgID, id); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+// ListMappers handles GET /api/v1/ai-o11y/mapping/groups/{id}/mappers.
+func (h *handler) ListMappers(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groupID, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	mappers, err := h.module.ListMappers(ctx, orgID, groupID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	items := make([]*spanattributemappingtypes.GettableMapper, len(mappers))
+	for i, m := range mappers {
+		items[i] = spanattributemappingtypes.NewGettableMapper(m)
+	}
+
+	render.Success(rw, http.StatusOK, &spanattributemappingtypes.ListMappersResponse{Items: items})
+}
+
+// CreateMapper handles POST /api/v1/ai-o11y/mapping/groups/{id}/mappers.
+func (h *handler) CreateMapper(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groupID, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(spanattributemappingtypes.PostableMapper)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	mapper, err := h.module.CreateMapper(ctx, orgID, groupID, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusCreated, spanattributemappingtypes.NewGettableMapper(mapper))
+}
+
+// UpdateMapper handles PUT /api/v1/ai-o11y/mapping/groups/{groupId}/mappers/{mapperId}.
+func (h *handler) UpdateMapper(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groupID, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	mapperID, err := mapperIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	req := new(spanattributemappingtypes.UpdatableMapper)
+	if err := binding.JSON.BindBody(r.Body, req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	mapper, err := h.module.UpdateMapper(ctx, orgID, groupID, mapperID, claims.Email, req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, spanattributemappingtypes.NewGettableMapper(mapper))
+}
+
+// DeleteMapper handles DELETE /api/v1/ai-o11y/mapping/groups/{groupId}/mappers/{mapperId}.
+func (h *handler) DeleteMapper(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	groupID, err := groupIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	mapperID, err := mapperIDFromPath(r)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if err := h.module.DeleteMapper(ctx, orgID, groupID, mapperID); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusNoContent, nil)
+}
+
+// groupIDFromPath extracts and validates the {id} or {groupId} path variable.
+func groupIDFromPath(r *http.Request) (valuer.UUID, error) {
+	vars := mux.Vars(r)
+	raw := vars["groupId"]
+	if raw == "" {
+		raw = vars["id"]
+	}
+	if raw == "" {
+		return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "group id is missing from the path")
+	}
+	id, err := valuer.NewUUID(raw)
+	if err != nil {
+		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "group id is not a valid uuid")
+	}
+	return id, nil
+}
+
+// mapperIDFromPath extracts and validates the {mapperId} path variable.
+func mapperIDFromPath(r *http.Request) (valuer.UUID, error) {
+	raw := mux.Vars(r)["mapperId"]
+	if raw == "" {
+		return valuer.UUID{}, errors.Newf(errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "mapper id is missing from the path")
+	}
+	id, err := valuer.NewUUID(raw)
+	if err != nil {
+		return valuer.UUID{}, errors.Wrapf(err, errors.TypeInvalidInput, spanattributemappingtypes.ErrCodeSpanAttributeMappingInvalidInput, "mapper id is not a valid uuid")
+	}
+	return id, nil
+}
--- a/pkg/modules/spanattributemapping/spanattributemapping.go
+++ b/pkg/modules/spanattributemapping/spanattributemapping.go
@@ -0,0 +1,41 @@
+package spanattributemapping
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/SigNoz/signoz/pkg/types/spanattributemappingtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// Module defines the business logic for span attribute mapping groups and mappers.
+type Module interface {
+	// Group operations
+	ListGroups(ctx context.Context, orgID valuer.UUID, q *spanattributemappingtypes.ListGroupsQuery) ([]*spanattributemappingtypes.Group, error)
+	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Group, error)
+	CreateGroup(ctx context.Context, orgID valuer.UUID, createdBy string, req *spanattributemappingtypes.PostableGroup) (*spanattributemappingtypes.Group, error)
+	UpdateGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, req *spanattributemappingtypes.UpdatableGroup) (*spanattributemappingtypes.Group, error)
+	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
+
+	// Mapper operations
+	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*spanattributemappingtypes.Mapper, error)
+	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*spanattributemappingtypes.Mapper, error)
+	CreateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, createdBy string, req *spanattributemappingtypes.PostableMapper) (*spanattributemappingtypes.Mapper, error)
+	UpdateMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID, updatedBy string, req *spanattributemappingtypes.UpdatableMapper) (*spanattributemappingtypes.Mapper, error)
+	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
+}
+
+// Handler defines the HTTP handler interface for mapping group and mapper endpoints.
+type Handler interface {
+	// Group handlers
+	ListGroups(rw http.ResponseWriter, r *http.Request)
+	CreateGroup(rw http.ResponseWriter, r *http.Request)
+	UpdateGroup(rw http.ResponseWriter, r *http.Request)
+	DeleteGroup(rw http.ResponseWriter, r *http.Request)
+
+	// Mapper handlers
+	ListMappers(rw http.ResponseWriter, r *http.Request)
+	CreateMapper(rw http.ResponseWriter, r *http.Request)
+	UpdateMapper(rw http.ResponseWriter, r *http.Request)
+	DeleteMapper(rw http.ResponseWriter, r *http.Request)
+}
--- a/pkg/signoz/handler.go
+++ b/pkg/signoz/handler.go
@@ -3,8 +3,6 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
-	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/authz/signozauthzapi"
@@ -36,38 +34,43 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/services"
 	"github.com/SigNoz/signoz/pkg/modules/services/implservices"
+	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
+	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping/implspanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/spanpercentile/implspanpercentile"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel"
 	"github.com/SigNoz/signoz/pkg/modules/tracefunnel/impltracefunnel"
 	"github.com/SigNoz/signoz/pkg/querier"
+	"github.com/SigNoz/signoz/pkg/ruler"
+	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )

 type Handlers struct {
-	SavedView               savedview.Handler
-	Apdex                   apdex.Handler
-	Dashboard               dashboard.Handler
-	QuickFilter             quickfilter.Handler
-	TraceFunnel             tracefunnel.Handler
-	RawDataExport           rawdataexport.Handler
-	SpanPercentile          spanpercentile.Handler
-	Services                services.Handler
-	MetricsExplorer         metricsexplorer.Handler
-	Global                  global.Handler
-	FlaggerHandler          flagger.Handler
-	GatewayHandler          gateway.Handler
-	Fields                  fields.Handler
-	AuthzHandler            authz.Handler
-	ZeusHandler             zeus.Handler
-	QuerierHandler          querier.Handler
-	ServiceAccountHandler   serviceaccount.Handler
-	RegistryHandler         factory.Handler
-	CloudIntegrationHandler cloudintegration.Handler
-	RuleStateHistory        rulestatehistory.Handler
-	AlertmanagerHandler     alertmanager.Handler
-	RulerHandler            ruler.Handler
+	SavedView                  savedview.Handler
+	Apdex                      apdex.Handler
+	Dashboard                  dashboard.Handler
+	QuickFilter                quickfilter.Handler
+	TraceFunnel                tracefunnel.Handler
+	RawDataExport              rawdataexport.Handler
+	SpanPercentile             spanpercentile.Handler
+	Services                   services.Handler
+	MetricsExplorer            metricsexplorer.Handler
+	Global                     global.Handler
+	FlaggerHandler             flagger.Handler
+	GatewayHandler             gateway.Handler
+	Fields                     fields.Handler
+	AuthzHandler               authz.Handler
+	ZeusHandler                zeus.Handler
+	QuerierHandler             querier.Handler
+	ServiceAccountHandler      serviceaccount.Handler
+	RegistryHandler            factory.Handler
+	CloudIntegrationHandler    cloudintegration.Handler
+	RuleStateHistory           rulestatehistory.Handler
+	SpanAttributeMappingHander spanattributemapping.Handler
+	AlertmanagerHandler        alertmanager.Handler
+	RulerHandler               ruler.Handler
 }

 func NewHandlers(
@@ -87,27 +90,28 @@ func NewHandlers(
 	rulerService ruler.Ruler,
 ) Handlers {
 	return Handlers{
-		SavedView:               implsavedview.NewHandler(modules.SavedView),
-		Apdex:                   implapdex.NewHandler(modules.Apdex),
-		Dashboard:               impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
-		QuickFilter:             implquickfilter.NewHandler(modules.QuickFilter),
-		TraceFunnel:             impltracefunnel.NewHandler(modules.TraceFunnel),
-		RawDataExport:           implrawdataexport.NewHandler(modules.RawDataExport),
-		Services:                implservices.NewHandler(modules.Services),
-		MetricsExplorer:         implmetricsexplorer.NewHandler(modules.MetricsExplorer),
-		SpanPercentile:          implspanpercentile.NewHandler(modules.SpanPercentile),
-		Global:                  signozglobal.NewHandler(global),
-		FlaggerHandler:          flagger.NewHandler(flaggerService),
-		GatewayHandler:          gateway.NewHandler(gatewayService),
-		Fields:                  implfields.NewHandler(providerSettings, telemetryMetadataStore),
-		AuthzHandler:            signozauthzapi.NewHandler(authz),
-		ZeusHandler:             zeus.NewHandler(zeusService, licensing),
-		QuerierHandler:          querierHandler,
-		ServiceAccountHandler:   implserviceaccount.NewHandler(modules.ServiceAccount),
-		RegistryHandler:         registryHandler,
-		RuleStateHistory:        implrulestatehistory.NewHandler(modules.RuleStateHistory),
-		CloudIntegrationHandler: implcloudintegration.NewHandler(modules.CloudIntegration),
-		AlertmanagerHandler:     signozalertmanager.NewHandler(alertmanagerService),
-		RulerHandler:            signozruler.NewHandler(rulerService),
+		SavedView:                  implsavedview.NewHandler(modules.SavedView),
+		Apdex:                      implapdex.NewHandler(modules.Apdex),
+		Dashboard:                  impldashboard.NewHandler(modules.Dashboard, providerSettings, authz),
+		QuickFilter:                implquickfilter.NewHandler(modules.QuickFilter),
+		TraceFunnel:                impltracefunnel.NewHandler(modules.TraceFunnel),
+		RawDataExport:              implrawdataexport.NewHandler(modules.RawDataExport),
+		Services:                   implservices.NewHandler(modules.Services),
+		MetricsExplorer:            implmetricsexplorer.NewHandler(modules.MetricsExplorer),
+		SpanPercentile:             implspanpercentile.NewHandler(modules.SpanPercentile),
+		Global:                     signozglobal.NewHandler(global),
+		FlaggerHandler:             flagger.NewHandler(flaggerService),
+		GatewayHandler:             gateway.NewHandler(gatewayService),
+		Fields:                     implfields.NewHandler(providerSettings, telemetryMetadataStore),
+		AuthzHandler:               signozauthzapi.NewHandler(authz),
+		ZeusHandler:                zeus.NewHandler(zeusService, licensing),
+		QuerierHandler:             querierHandler,
+		ServiceAccountHandler:      implserviceaccount.NewHandler(modules.ServiceAccount),
+		RegistryHandler:            registryHandler,
+		RuleStateHistory:           implrulestatehistory.NewHandler(modules.RuleStateHistory),
+		CloudIntegrationHandler:    implcloudintegration.NewHandler(modules.CloudIntegration),
+		SpanAttributeMappingHander: implspanattributemapping.NewHandler(nil, providerSettings), // todo(nitya): will update this in future PR
+		AlertmanagerHandler:        signozalertmanager.NewHandler(alertmanagerService),
+		RulerHandler:               signozruler.NewHandler(rulerService),
 	}
 }
--- a/pkg/signoz/openapi.go
+++ b/pkg/signoz/openapi.go
@@ -29,6 +29,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/session"
+	"github.com/SigNoz/signoz/pkg/modules/spanattributemapping"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
@@ -71,6 +72,7 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ factory.Handler }{},
 		struct{ cloudintegration.Handler }{},
 		struct{ rulestatehistory.Handler }{},
+		struct{ spanattributemapping.Handler }{},
 		struct{ alertmanager.Handler }{},
 		struct{ ruler.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
--- a/pkg/signoz/provider.go
+++ b/pkg/signoz/provider.go
@@ -3,8 +3,6 @@ package signoz
 import (
 	"github.com/SigNoz/signoz/pkg/alertmanager"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager"
-	"github.com/SigNoz/signoz/pkg/auditor"
-	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/alertmanager/nfmanager/rulebasednotification"
 	"github.com/SigNoz/signoz/pkg/alertmanager/signozalertmanager"
 	"github.com/SigNoz/signoz/pkg/analytics"
@@ -12,6 +10,8 @@ import (
 	"github.com/SigNoz/signoz/pkg/analytics/segmentanalytics"
 	"github.com/SigNoz/signoz/pkg/apiserver"
 	"github.com/SigNoz/signoz/pkg/apiserver/signozapiserver"
+	"github.com/SigNoz/signoz/pkg/auditor"
+	"github.com/SigNoz/signoz/pkg/auditor/noopauditor"
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/cache"
 	"github.com/SigNoz/signoz/pkg/cache/memorycache"
@@ -226,8 +226,6 @@ func NewAlertmanagerProviderFactories(sqlstore sqlstore.SQLStore, orgGetter orga
 	)
 }

-
-
 func NewEmailingProviderFactories() factory.NamedMap[factory.ProviderFactory[emailing.Emailing, emailing.Config]] {
 	return factory.MustNewNamedMap(
 		noopemailing.NewFactory(),
@@ -281,6 +279,7 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.RegistryHandler,
 			handlers.CloudIntegrationHandler,
 			handlers.RuleStateHistory,
+			handlers.SpanAttributeMappingHander,
 			handlers.AlertmanagerHandler,
 			handlers.RulerHandler,
 		),
--- a/pkg/types/spanattributemappingtypes/errors.go
+++ b/pkg/types/spanattributemappingtypes/errors.go
@@ -0,0 +1,11 @@
+package spanattributemappingtypes
+
+import "github.com/SigNoz/signoz/pkg/errors"
+
+var (
+	ErrCodeSpanAttributeMappingGroupNotFound      = errors.MustNewCode("span_attribute_mapping_group_not_found")
+	ErrCodeSpanAttributeMappingGroupAlreadyExists = errors.MustNewCode("span_attribute_mapping_group_already_exists")
+	ErrCodeSpanAttributeMapperNotFound            = errors.MustNewCode("span_attribute_mapper_not_found")
+	ErrCodeSpanAttributeMapperAlreadyExists       = errors.MustNewCode("span_attribute_mapper_already_exists")
+	ErrCodeSpanAttributeMappingInvalidInput       = errors.MustNewCode("span_attribute_mapping_invalid_input")
+)
--- a/pkg/types/spanattributemappingtypes/group.go
+++ b/pkg/types/spanattributemappingtypes/group.go
@@ -0,0 +1,108 @@
+package spanattributemappingtypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// as of now it can be llm, tool, agent but can extend to more things in future.
+type GroupCategory string
+
+// A group runs when any of the listed attribute/resource key patterns match.
+type Condition struct {
+	Attributes []string `json:"attributes"`
+	Resource   []string `json:"resource"`
+}
+
+func (c Condition) Value() (driver.Value, error) {
+	b, err := json.Marshal(c)
+	if err != nil {
+		return nil, err
+	}
+	return string(b), nil
+}
+
+func (c *Condition) Scan(src any) error {
+	var raw []byte
+	switch v := src.(type) {
+	case string:
+		raw = []byte(v)
+	case []byte:
+		raw = v
+	case nil:
+		*c = Condition{}
+		return nil
+	default:
+		return errors.NewInternalf(errors.CodeInternal, "spanattributemappingtypes: cannot scan %T into Condition", src)
+	}
+	return json.Unmarshal(raw, c)
+}
+
+// Group is the domain model for a span attribute mapping group.
+type Group struct {
+	types.TimeAuditable
+	types.UserAuditable
+
+	ID        valuer.UUID   `json:"id" required:"true"`
+	OrgID     valuer.UUID   `json:"ordId" required:"true"`
+	Name      string        `json:"name" required:"true"`
+	Category  GroupCategory `json:"category" required:"true"`
+	Condition Condition     `json:"condition" required:"true"`
+	Enabled   bool          `json:"enabled" required:"true"`
+}
+
+func NewGroupFromStorable(s *StorableGroup) *Group {
+	return &Group{
+		TimeAuditable: s.TimeAuditable,
+		UserAuditable: s.UserAuditable,
+		ID:            s.ID,
+		OrgID:         s.OrgID,
+		Name:          s.Name,
+		Category:      s.Category,
+		Condition:     s.Condition,
+		Enabled:       s.Enabled,
+	}
+}
+
+func NewGroupsFromStorable(ss []*StorableGroup) []*Group {
+	groups := make([]*Group, len(ss))
+	for i, s := range ss {
+		groups[i] = NewGroupFromStorable(s)
+	}
+	return groups
+}
+
+// GettableGroup is the HTTP response representation of a mapping group.
+type GettableGroup = Group
+
+func NewGettableGroup(g *Group) *GettableGroup {
+	return g
+}
+
+type PostableGroup struct {
+	Name      string        `json:"name"      required:"true"`
+	Category  GroupCategory `json:"category"  required:"true"`
+	Condition Condition     `json:"condition" required:"true"`
+	Enabled   bool          `json:"enabled"`
+}
+
+// UpdatableGroup is the HTTP request body for updating a mapping group.
+// All fields are optional; only non-nil fields are applied.
+type UpdatableGroup struct {
+	Name      *string    `json:"name,omitempty"`
+	Condition *Condition `json:"condition,omitempty"`
+	Enabled   *bool      `json:"enabled,omitempty"`
+}
+
+type ListGroupsQuery struct {
+	Category *GroupCategory `query:"category"`
+	Enabled  *bool          `query:"enabled"`
+}
+
+type ListGroupsResponse struct {
+	Items []*GettableGroup `json:"items" required:"true" nullable:"true"`
+}
--- a/pkg/types/spanattributemappingtypes/mapper.go
+++ b/pkg/types/spanattributemappingtypes/mapper.go
@@ -0,0 +1,131 @@
+package spanattributemappingtypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// FieldContext is where the target attribute is written.
+type FieldContext string
+
+const (
+	FieldContextSpanAttribute FieldContext = "attribute"
+	FieldContextResource      FieldContext = "resource"
+)
+
+func (FieldContext) Enum() []any {
+	return []any{FieldContextSpanAttribute, FieldContextResource}
+}
+
+// MapperOperation determines whether the source attribute is moved (deleted) or copied.
+type MapperOperation string
+
+const (
+	MapperOperationMove MapperOperation = "move"
+	MapperOperationCopy MapperOperation = "copy"
+)
+
+func (MapperOperation) Enum() []any {
+	return []any{MapperOperationMove, MapperOperationCopy}
+}
+
+// MapperSource describes one candidate source for a target attribute.
+type MapperSource struct {
+	Key       string          `json:"key"`
+	Context   FieldContext    `json:"context"`
+	Operation MapperOperation `json:"operation"`
+	Priority  int             `json:"priority"`
+}
+
+// MapperConfig holds the mapping logic for a single target attribute.
+// It implements driver.Valuer and sql.Scanner for JSON text column storage.
+type MapperConfig struct {
+	Sources []MapperSource `json:"sources"`
+}
+
+func (m MapperConfig) Value() (driver.Value, error) {
+	b, err := json.Marshal(m)
+	if err != nil {
+		return nil, err
+	}
+	return string(b), nil
+}
+
+func (m *MapperConfig) Scan(src any) error {
+	var raw []byte
+	switch v := src.(type) {
+	case string:
+		raw = []byte(v)
+	case []byte:
+		raw = v
+	case nil:
+		*m = MapperConfig{}
+		return nil
+	default:
+		return errors.NewInternalf(errors.CodeInternal, "spanattributemapping: cannot scan %T into MapperConfig", src)
+	}
+	return json.Unmarshal(raw, m)
+}
+
+// Mapper is the domain model for a span attribute mapper.
+type Mapper struct {
+	types.TimeAuditable
+	types.UserAuditable
+
+	ID           valuer.UUID  `json:"id"            required:"true"`
+	GroupID      valuer.UUID  `json:"group_id"      required:"true"`
+	Name         string       `json:"name"          required:"true"`
+	FieldContext FieldContext `json:"field_context" required:"true"`
+	Config       MapperConfig `json:"config"        required:"true"`
+	Enabled      bool         `json:"enabled"       required:"true"`
+}
+
+func NewMapperFromStorable(s *StorableMapper) *Mapper {
+	return &Mapper{
+		TimeAuditable: s.TimeAuditable,
+		UserAuditable: s.UserAuditable,
+		ID:            s.ID,
+		GroupID:       s.GroupID,
+		Name:          s.Name,
+		FieldContext:  s.FieldContext,
+		Config:        s.Config,
+		Enabled:       s.Enabled,
+	}
+}
+
+func NewMappersFromStorable(ss []*StorableMapper) []*Mapper {
+	mappers := make([]*Mapper, len(ss))
+	for i, s := range ss {
+		mappers[i] = NewMapperFromStorable(s)
+	}
+	return mappers
+}
+
+type GettableMapper = Mapper
+
+func NewGettableMapper(m *Mapper) *GettableMapper {
+	return m
+}
+
+type PostableMapper struct {
+	Name         string       `json:"name"          required:"true"`
+	FieldContext FieldContext `json:"field_context" required:"true"`
+	Config       MapperConfig `json:"config"        required:"true"`
+	Enabled      bool         `json:"enabled"`
+}
+
+// UpdatableMapper is the HTTP request body for updating a mapper.
+// All fields are optional; only non-nil fields are applied.
+type UpdatableMapper struct {
+	FieldContext FieldContext  `json:"field_context,omitempty"`
+	Config       *MapperConfig `json:"config,omitempty"`
+	Enabled      *bool         `json:"enabled,omitempty"`
+}
+
+type ListMappersResponse struct {
+	Items []*GettableMapper `json:"items" required:"true" nullable:"true"`
+}
--- a/pkg/types/spanattributemappingtypes/storable.go
+++ b/pkg/types/spanattributemappingtypes/storable.go
@@ -0,0 +1,35 @@
+package spanattributemappingtypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/valuer"
+	"github.com/uptrace/bun"
+)
+
+type StorableGroup struct {
+	bun.BaseModel `bun:"table:span_attribute_mapping_group,alias:span_attribute_mapping_group"`
+
+	types.Identifiable
+	types.TimeAuditable
+	types.UserAuditable
+
+	OrgID     valuer.UUID   `bun:"org_id,type:text,notnull"`
+	Name      string        `bun:"name,type:text,notnull"`
+	Category  GroupCategory `bun:"category,type:text,notnull"`
+	Condition Condition     `bun:"condition,type:text,notnull"`
+	Enabled   bool          `bun:"enabled,notnull,default:true"`
+}
+
+type StorableMapper struct {
+	bun.BaseModel `bun:"table:span_attribute_mapping,alias:span_attribute_mapping"`
+
+	types.Identifiable
+	types.TimeAuditable
+	types.UserAuditable
+
+	GroupID      valuer.UUID  `bun:"group_id,type:text,notnull"`
+	Name         string       `bun:"name,type:text,notnull"`
+	FieldContext FieldContext `bun:"field_context,type:text,notnull"`
+	Config       MapperConfig `bun:"config,type:text,notnull"`
+	Enabled      bool         `bun:"enabled,notnull,default:true"`
+}
--- a/pkg/types/spanattributemappingtypes/store.go
+++ b/pkg/types/spanattributemappingtypes/store.go
@@ -0,0 +1,23 @@
+package spanattributemappingtypes
+
+import (
+	"context"
+
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Store interface {
+	// Group operations
+	ListGroups(ctx context.Context, orgID valuer.UUID, q *ListGroupsQuery) ([]*StorableGroup, error)
+	GetGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*StorableGroup, error)
+	CreateGroup(ctx context.Context, group *StorableGroup) error
+	UpdateGroup(ctx context.Context, group *StorableGroup) error
+	DeleteGroup(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
+
+	// Mapper operations
+	ListMappers(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID) ([]*StorableMapper, error)
+	GetMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) (*StorableMapper, error)
+	CreateMapper(ctx context.Context, mapper *StorableMapper) error
+	UpdateMapper(ctx context.Context, mapper *StorableMapper) error
+	DeleteMapper(ctx context.Context, orgID valuer.UUID, groupID valuer.UUID, id valuer.UUID) error
+}
Author	SHA1	Message	Date
nityanandagohain	50b42aca8c	fix: lint issues	2026-04-20 16:09:50 +05:30
nityanandagohain	dbad6cff96	Merge remote-tracking branch 'origin/issue_4361' into issue_4361	2026-04-20 16:09:35 +05:30
nityanandagohain	73a44cee77	Merge remote-tracking branch 'origin/main' into issue_4361	2026-04-20 16:09:12 +05:30
nityanandagohain	b9b7c10af9	fix: remove lint issues	2026-04-20 16:09:09 +05:30
Nityananda Gohain	3d71707f0b	Merge branch 'main' into issue_4361	2026-04-20 11:02:57 +05:30
nityanandagohain	f59f611ea2	fix: remove stutters	2026-04-20 11:00:38 +05:30
nityanandagohain	07131f10a9	fix: minor changes	2026-04-20 10:52:17 +05:30
nityanandagohain	d930e77870	fix: cleanup	2026-04-20 10:40:36 +05:30
nityanandagohain	8a9f6bee98	Merge remote-tracking branch 'origin/main' into issue_4361	2026-04-20 09:14:50 +05:30
nityanandagohain	4b06b4546f	Merge remote-tracking branch 'origin/issue_4361' into issue_4361	2026-04-12 22:02:12 +05:30
nityanandagohain	526b08a179	feat: 1.types and handler for ai-o11y attribute mapping	2026-04-12 17:32:30 +05:30
nityanandagohain	c7ab610bd8	feat: 1.types and handler for ai-o11y attribute mapping	2026-04-12 17:31:40 +05:30