ALTR Classifiers API

openapi: 3.2.0
info:
  contact:
    email: support@altr.com
    name: API Support
  description: This API manages classifiers, collections, and classification reports for ALTR's classification engine.
  termsOfService: https://altr.com/info/altr-solutions-inc-terms-of-service/
  title: ALTR Classification Engine Classifiers API
  version: 1.1.0
servers:
- url: https://{orgID}.classification.live.altr.com/v1
  variables:
    orgID:
      default: ''
security:
- basic: []
tags:
- name: Classifiers
paths:
  /classifiers:
    get:
      description: Retrieves a list of all classifiers with optional pagination, prefix filtering, and sorting. Use exclude_collection to filter out classifiers already assigned to a specific collection.
      parameters:
      - description: 'Number of items to return (default: 100, max: 100)'
        example: 100
        in: query
        name: limit
        schema:
          type: integer
      - description: Continuation token for pagination (returned in previous response)
        example: eyJQSyI6eyJTIjoiT1JHSUQjMTIzNDU2Nzg5MCJ9fQ
        in: query
        name: contiguous_id
        schema:
          type: string
      - description: Prefix to filter classifier names (e.g., 'email' matches 'email_address', 'email_domain')
        example: email
        in: query
        name: prefix
        schema:
          type: string
      - description: 'Field to order by: ''name'' (alphabetical) or ''collection_count'' (number of collections using this classifier)'
        example: name
        in: query
        name: order_by
        schema:
          enum:
          - name
          - collection_count
          type: string
      - description: 'Sort order: ''asc'' (ascending) or ''desc'' (descending)'
        example: asc
        in: query
        name: sort_order
        schema:
          enum:
          - asc
          - desc
          type: string
      - description: Exclude classifiers that belong to this collection (useful when adding classifiers to a collection)
        example: pii_data
        in: query
        name: exclude_collection
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/management.GetClassifiersOutput'
          description: List of classifiers
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Invalid request or validation error
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Internal server error
      security:
      - basic: []
      summary: List classifiers
      tags:
      - Classifiers
    post:
      description: 'Creates a new classifier. Pattern uses RE2 regex syntax. Classifier names starting with ''ALTR'' are reserved. Sampling (sample_size, sample_type) is configured on the job, not the classifier.


        Three modes are supported:


        **Legacy (regex only)** — Provide a top-level `pattern` and `minimum_threshold`. No compound_ruleset needed.


        **Regex + metadata filter** — Same top-level pattern fields, plus a `compound_ruleset` with METADATA or COLUMN_LOCATION conditions to narrow matches.


        **Compound ruleset (advanced)** — All logic inside `compound_ruleset`. Each leaf condition specifies its own `target` (ROW_DATA, METADATA, or COLUMN_LOCATION), pattern, and optional per-condition minimum_threshold. No top-level pattern needed.


        Each condition supports a `negated` boolean (default false) to invert the match. Conditions can be nested groups with their own `operator` + `conditions` array.


        **METADATA vs COLUMN_LOCATION** — A METADATA condition matches on the column NAME (e.g. `{"target":"METADATA","comparator":"contains","pattern":"ssn"}`). A COLUMN_LOCATION condition matches on WHERE the column lives and accepts only `database`, `schema`, and/or `table` (e.g. `{"target":"COLUMN_LOCATION","location":{"database":"prod_db","schema":"pii","table":"customers"}}`); `"*"` or an omitted field means any. A `column` field on COLUMN_LOCATION is rejected with 400 — use a METADATA condition for column-name matching.


        See the request body examples dropdown for complete payloads.'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/classifiers.PostClassifierInput'
            examples:
              Legacy (regex only):
                summary: Regex-only classifier — sampling is configured on the job
                value:
                  classifier_name: ssn_regex
                  pattern: \d{3}-\d{2}-\d{4}
                  minimum_threshold: 70
              Regex + metadata filter:
                summary: Regex with compound metadata condition
                value:
                  classifier_name: ssn_with_name_check
                  pattern: \d{3}-\d{2}-\d{4}
                  minimum_threshold: 70
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: METADATA
                      comparator: contains
                      pattern: ssn
              Compound ruleset (all target types):
                summary: Self-contained compound with ROW_DATA, METADATA, and COLUMN_LOCATION. Sampling is configured on the job.
                value:
                  classifier_name: ssn_full_detection
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: ROW_DATA
                      comparator: matches
                      pattern: \d{3}-\d{2}-\d{4}
                      minimum_threshold: 70
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)ssn|social_security
                    - target: COLUMN_LOCATION
                      location:
                        schema: pii
              Nested groups (credit card multi-path):
                summary: Complex nested ruleset with OR-of-ANDs and negation. Sampling is configured on the job.
                value:
                  classifier_name: credit_card_advanced
                  description: Detects credit cards via two detection paths with false-positive exclusion
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - operator: AND
                      conditions:
                      - target: METADATA
                        comparator: matches
                        pattern: card_num|cc_num|credit_card|pan
                      - target: ROW_DATA
                        comparator: matches
                        pattern: \d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}
                        minimum_threshold: 50
                      - target: COLUMN_LOCATION
                        location:
                          schema: payments
                    - operator: AND
                      conditions:
                      - target: ROW_DATA
                        comparator: matches
                        pattern: ^3[47]\d{13}$
                        minimum_threshold: 80
                      - operator: AND
                        negated: true
                        conditions:
                        - target: METADATA
                          comparator: matches
                          pattern: phone|zip|postal|quantity|amount
              GDLP compound (GDLP + METADATA AND):
                summary: Classifier using GDLP infoType detection AND metadata column name check. Requires GCP credentials at classification runtime.
                value:
                  classifier_name: email_gdlp_compound
                  description: Classifies email columns using Google DLP EMAIL_ADDRESS detection AND column name heuristic
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: GDLP
                      info_type: EMAIL_ADDRESS
                      minimum_likelihood: POSSIBLE
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)email|e_mail|mail_addr
              'GDLP compound (OR: GDLP EMAIL or GDLP PHONE)':
                summary: Classifier that triggers if a column contains either email addresses OR phone numbers according to Google DLP.
                value:
                  classifier_name: email_or_phone_gdlp
                  description: Detects columns containing PII contact information via Google DLP
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: GDLP
                      info_type: EMAIL_ADDRESS
                      minimum_likelihood: LIKELY
                    - target: GDLP
                      info_type: PHONE_NUMBER
                      minimum_likelihood: LIKELY
              Snowflake Native compound (SEMANTIC_CATEGORY EMAIL):
                summary: Classifier that fires when Snowflake's native classifier tags a column with SEMANTIC_CATEGORY = EMAIL. Auto-resolves with evaluated=false on non-Snowflake sources.
                value:
                  classifier_name: snowflake_native_email
                  description: Detects email columns via Snowflake's native classifier SEMANTIC_CATEGORY tag
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: EMAIL
              'Snowflake Native compound (OR: SEMANTIC EMAIL or METADATA hint)':
                summary: Hybrid classifier — fires when Snowflake tags the column EMAIL OR the column name matches an email heuristic.
                value:
                  classifier_name: email_snowflake_or_name
                  description: Falls back to column-name heuristic when Snowflake's native classifier did not tag the column
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: EMAIL
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)email|e_mail|mail_addr
              Snowflake Native compound (PRIVACY_CATEGORY IDENTIFIER):
                summary: Governance classifier scoped to columns Snowflake tagged with PRIVACY_CATEGORY = IDENTIFIER
                value:
                  classifier_name: snowflake_identifier
                  description: Detects all identifier columns flagged by Snowflake's native classifier
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: SNOWFLAKE_NATIVE
                      privacy_category: IDENTIFIER
              Snowflake Native compound (with confidence + coverage thresholds):
                summary: SSN classifier that fires only when Snowflake tags the column SEMANTIC_CATEGORY = US_SSN with HIGH confidence AND coverage >= 0.80. Defaults are LOW / 0.70 when these fields are omitted — set them when you want a stricter gate. minimum_confidence ranks HIGH > MEDIUM > LOW; minimum_coverage is a fraction (0.0-1.0). actual_confidence + actual_coverage are surfaced on the leaf's decision_lineage.
                value:
                  classifier_name: snowflake_native_ssn_strict
                  description: Detect SSN columns only when Snowflake's native classifier emits HIGH-confidence US_SSN with at least 80% coverage
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: US_SSN
                      minimum_confidence: HIGH
                      minimum_coverage: 0.8
              Cross-target hybrid (GDLP AND SNOWFLAKE_NATIVE):
                summary: Hybrid classifier mixing Google DLP infoType detection with Snowflake's native classifier tag. On the Snowflake GDLP path the worker fetches SEMANTIC_CATEGORY / PRIVACY_CATEGORY tags from INFORMATION_SCHEMA.TAG_REFERENCES_ALL_COLUMNS so BOTH leaves evaluate against real data on the same job — extreme coverage when stacking signals from two independent classifiers. On non-Snowflake sources the SNOWFLAKE_NATIVE leaf auto-resolves with evaluated=false (vacuous-true under AND).
                value:
                  classifier_name: email_gdlp_and_snowflake_native
                  description: Email classifier requiring both Google DLP EMAIL_ADDRESS detection AND a Snowflake SEMANTIC_CATEGORY=EMAIL tag — minimizes false positives by stacking two independent signals
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: GDLP
                      info_type: EMAIL_ADDRESS
                      minimum_likelihood: POSSIBLE
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: EMAIL
              Cross-target hybrid (GDLP OR SNOWFLAKE_NATIVE OR METADATA):
                summary: Maximum-recall classifier — fires if any of Google DLP, Snowflake's native classifier, or column-name heuristic flags the column. Production-shape fallback that survives missing signals from any single source.
                value:
                  classifier_name: email_any_signal
                  description: Detect email columns via Google DLP OR Snowflake native classifier OR column-name heuristic — any one fires the classifier
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: GDLP
                      info_type: EMAIL_ADDRESS
                      minimum_likelihood: LIKELY
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: EMAIL
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)email|e_mail|mail_addr
              All five condition targets (extreme coverage):
                summary: Compound spanning every supported condition target — ROW_DATA + METADATA + COLUMN_LOCATION + GDLP + SNOWFLAKE_NATIVE. Demonstrates the full type system. Each leaf carries its evaluated flag in lineage; unevaluable targets on a given path (e.g., ROW_DATA on SF GDLP, SF_NATIVE on non-Snowflake) auto-resolve vacuous-true under AND.
                value:
                  classifier_name: ssn_all_five_targets
                  description: Stacks regex + name heuristic + schema scoping + Google DLP US_SOCIAL_SECURITY_NUMBER + Snowflake SEMANTIC_CATEGORY tag
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: ROW_DATA
                      comparator: matches
                      pattern: \d{3}-\d{2}-\d{4}
                      minimum_threshold: 70
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)ssn|social_security
                    - target: COLUMN_LOCATION
                      location:
                        schema: pii
                    - target: GDLP
                      info_type: US_SOCIAL_SECURITY_NUMBER
                      minimum_likelihood: LIKELY
                    - target: SNOWFLAKE_NATIVE
                      semantic_category: US_SOCIAL_SECURITY_NUMBER
              CONTENT_TYPE — single format match (JSON):
                summary: Classifier that triggers when the dominant detected content format of a column is JSON. Single content_format value performs an equality check; default dominance threshold is 0.8.
                value:
                  classifier_name: json_payload_columns
                  description: Flags columns whose sampled rows are predominantly JSON-formatted
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: CONTENT_TYPE
                      content_format: JSON
              CONTENT_TYPE — any-of list with custom threshold:
                summary: Multi-format any-of match. Classifier fires when the dominant detected format is JSON, XML, or YAML and the dominance ratio is at least 0.6 (60% of sampled values share the format).
                value:
                  classifier_name: structured_payload
                  description: Detects columns holding structured (non-tabular) payloads
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: CONTENT_TYPE
                      content_formats:
                      - JSON
                      - XML
                      - YAML
                      dominance_threshold: 0.6
              CONTENT_TYPE — negated (NOT base64):
                summary: 'Negated CT leaf: classifier triggers on every column whose dominant detected format is NOT BASE64.'
                value:
                  classifier_name: non_base64_columns
                  description: Excludes opaque base64-encoded blob columns
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: CONTENT_TYPE
                      content_format: BASE64
                      negated: true
              DATA_LENGTH — values longer than 100 bytes:
                summary: Classifier that triggers when at least 80% (the default minimum_threshold) of a column's sampled values are longer than 100 bytes. Length is the true data size — the UTF-8 byte length of each sampled value.
                value:
                  classifier_name: long_text_columns
                  description: Flags columns holding large free-text payloads
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: DATA_LENGTH
                      comparator: greater_than
                      length: 100
              DATA_LENGTH — exact length with whitespace trimmed:
                summary: 'Fixed-width identifier detection: fires when sampled values are exactly 9 bytes after surrounding whitespace is stripped (trim: true). Useful for CHAR(n) columns that pad values with spaces.'
                value:
                  classifier_name: nine_byte_identifiers
                  description: Flags columns whose values are exactly 9 bytes once padding is trimmed (e.g. unformatted SSNs)
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: DATA_LENGTH
                      comparator: equals
                      length: 9
                      trim: true
              DATA_LENGTH — short codes with custom threshold:
                summary: Fires when at least half the sampled values are 5 bytes or shorter (custom minimum_threshold of 50 instead of the default 80). Combine with less_than / less_than_or_equal / greater_than_or_equal for range-style rules.
                value:
                  classifier_name: short_code_columns
                  description: Detects columns dominated by short codes (zip prefixes, country codes, flags)
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: DATA_LENGTH
                      comparator: less_than_or_equal
                      length: 5
                      minimum_threshold: 50
              DATA_LENGTH compound (length + METADATA — oversized values in a notes column):
                summary: 'Compound AND combining a DATA_LENGTH check with a metadata column-name heuristic: fires on columns named like notes/comments whose values exceed 1000 bytes.'
                value:
                  classifier_name: oversized_notes
                  description: Flags free-text note columns carrying unexpectedly large payloads
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: DATA_LENGTH
                      comparator: greater_than
                      length: 1000
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)notes|comments|description
              COLUMN_SIZE — columns declared wider than 100:
                summary: Classifier that fires on columns whose declared catalog size exceeds 100 (e.g. VARCHAR(255)). COLUMN_SIZE compares the declared column size from schema metadata — binary per column (no trim, no minimum_threshold) and evaluable without row sampling.
                value:
                  classifier_name: wide_text_columns
                  description: Flags columns declared to hold large values
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: COLUMN_SIZE
                      comparator: greater_than
                      size: 100
              COLUMN_SIZE — exact declared size:
                summary: Fires on columns whose declared size is exactly 255 (e.g. VARCHAR(255)). Combine with less_than / less_than_or_equal / greater_than_or_equal for range-style rules on the declared size.
                value:
                  classifier_name: varchar_255_columns
                  description: Flags columns declared as size 255
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: COLUMN_SIZE
                      comparator: equals
                      size: 255
              COLUMN_SIZE compound (size + METADATA — oversized notes column by declaration):
                summary: 'Compound AND combining a COLUMN_SIZE check with a metadata column-name heuristic: fires on columns named like notes/comments that are declared wider than 1000.'
                value:
                  classifier_name: oversized_notes_by_declaration
                  description: Flags free-text note columns declared with very large sizes
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: COLUMN_SIZE
                      comparator: greater_than
                      size: 1000
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)notes|comments|description
              CONTENT_TYPE compound (CT + METADATA — JSON column whose name suggests PII):
                summary: Compound AND combining a CT format check with a metadata column-name heuristic. Fires only when both leaves evaluate to true on the same column.
                value:
                  classifier_name: json_with_email_field
                  description: Flags JSON columns whose name suggests they contain email addresses
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: CONTENT_TYPE
                      content_format: JSON
                    - target: METADATA
                      comparator: contains
                      pattern: email
              Amazon Comprehend — single entity (EMAIL ML detection):
                summary: Classifier that fires when AWS Comprehend's ML PII detection finds the EMAIL entity at >= minimum_score (0.5) confidence. Requires ROW_DATA sampling and AMAZON_COMPREHEND in the job's condition_types; auto-resolves evaluated=false on METADATA-only paths or when AMAZON_COMPREHEND is absent from condition_types.
                value:
                  classifier_name: email_comprehend
                  description: Detects email columns via AWS Comprehend DetectPiiEntities (EMAIL entity)
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: AMAZON_COMPREHEND
                      entity_type: EMAIL
                      minimum_score: 0.5
              Amazon Comprehend compound (AC AND METADATA — SSN):
                summary: Hybrid classifier requiring BOTH AWS Comprehend SSN detection (>= 0.8 confidence) AND a column-name heuristic — stacks an ML signal with a name check to cut false positives. AMAZON_COMPREHEND must be in condition_types and the job must sample rows.
                value:
                  classifier_name: ssn_comprehend_and_name
                  description: Detects SSN columns when Comprehend finds SSN at high confidence AND the column name matches an SSN heuristic
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: AMAZON_COMPREHEND
                      entity_type: SSN
                      minimum_score: 0.8
                    - target: METADATA
                      comparator: matches
                      pattern: (?i)ssn|social_security
              'Amazon Comprehend compound (OR: EMAIL or PHONE or SSN)':
                summary: Maximum-recall contact-PII classifier — fires when Comprehend detects ANY of EMAIL, PHONE, or SSN. Each leaf carries its own entity_type + minimum_score; the leaf's actual_score and finding_count are surfaced on the decision_lineage.
                value:
                  classifier_name: contact_pii_comprehend
                  description: Detects columns containing any contact PII via AWS Comprehend
                  compound_ruleset:
                    operator: OR
                    conditions:
                    - target: AMAZON_COMPREHEND
                      entity_type: EMAIL
                      minimum_score: 0.6
                    - target: AMAZON_COMPREHEND
                      entity_type: PHONE
                      minimum_score: 0.6
                    - target: AMAZON_COMPREHEND
                      entity_type: SSN
                      minimum_score: 0.6
              Cross-target hybrid (GDLP AND AMAZON_COMPREHEND):
                summary: 'Stacks two independent ML detectors: fires only when BOTH Google DLP and AWS Comprehend flag the column as containing names. On a given runtime each leaf auto-resolves evaluated=false where its detector is unavailable (e.g. AMAZON_COMPREHEND on the Snowflake native pushdown), vacuous-true under AND.'
                value:
                  classifier_name: name_gdlp_and_comprehend
                  description: Name classifier requiring both Google DLP PERSON_NAME AND AWS Comprehend NAME detection
                  compound_ruleset:
                    operator: AND
                    conditions:
                    - target: GDLP
                      info_type: PERSON_NAME
                      minimum_likelihood: POSSIBLE
                    - target: AMAZON_COMPREHEND
                      entity_type: NAME
                      minimum_score: 0.5
        description: Classifier creation input
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/management.CreateClassifierOutput'
          description: Classifier created successfully
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Invalid request or validation error
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Classifier already exists
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Internal server error
      security:
      - basic: []
      summary: Create classifier
      tags:
      - Classifiers
  /classifiers/{classifier_name}:
    delete:
      description: Soft deletes a classifier by its name. This will remove it from all collections and mark it as deleted. ALTR managed classifiers cannot be deleted.
      parameters:
      - description: Classifier name (URL-encoded if contains special characters)
        example: email_address
        in: path
        name: classifier_name
        required: true
        schema:
          type: string
      responses:
        '204':
          description: Classifier deleted successfully
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Invalid request or validation error
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Classifier not found
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Internal server error
      security:
      - basic: []
      summary: Delete classifier
      tags:
      - Classifiers
    get:
      description: Retrieves a specific classifier by its name, including its pattern, thresholds, and associated collections.
      parameters:
      - description: Classifier name (URL-encoded if contains special characters)
        example: email_address
        in: path
        name: classifier_name
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/management.GetClassifierByNameOutput'
          description: Classifier retrieved successfully
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Invalid request or validation error
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Classifier not found
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/fiber.APIError'
          description: Internal server error
      security:
      - basic: []
      summary: Get classifier by name
      tags:
      - Classifiers
    patch:
      description: 'Updates a classifier''s properties using RESTful PATCH semantics.


        **PATCH semantics**: Omitted fields are **preserved** (not modified). Only fields explicitly

        included in the request body are updated. This allows partial updates without affecting other fields.


        **Clearing fields**: To explicitly clear a field, send it with an empty/null/zero value:

        - Clear `pattern`: send `"pattern": ""` or `"pattern": null`

        - Clear `compound_ruleset`: send `"compound_ruleset": {}` or `"compound_ruleset": null`

        - Clear `minimum_threshold`: send `"minimum_threshold": 0` or `"minimum_threshold": null`

        - Clear `description`: send `"description": ""`


        **Validation**: A request that explicitly clears both `pattern` and `compound_ruleset` in the

        same request returns a 400 error.


        Supports the same three modes as POST /classifiers (legacy, regex + metadata filter, compound ruleset). See the POST endpoint and request body examples for details.


        Each condition supports a `negated` boolean (default false) to invert the match (NOT logic). Conditions can also be nested groups with their own `operator` + `conditions` array.'
      parameters:
      - description: Classifier name (URL-encoded if contains special characters)
        example: email_address
        in: path
        name: classifier_name
        required: true
        schema:
          type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/classifiers.PatchClassifierInput'
            examples:
              Update pattern only:
                summary: Update just the regex pattern
                value:
                  pattern: \d{3}-\d{2}-\d{4}
                  minimum_threshold: 80
 

# --- truncated at 32 KB (57 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/altr/refs/heads/main/openapi/altr-classifiers-api-openapi.yml