---
$context: https://schema.org.ai
$type: Product
$id: https://acme.com/products/company-data
name: Acme Company Database
type: Data
business: https://acme.com
description: Comprehensive B2B company and contact database
isActive: true

# Categorization
industries:
  - B2B SaaS
  - Data & Analytics
  - Sales Intelligence
productCategories:
  - Company Data
  - Contact Database
  - Firmographic Data

# Interfaces
interfaces:
  hasAPI: true
  hasRPC: false
  hasMCP: true
  hasSDK: true
  hasCLI: false
  hasSQL: true
  hasDownload: true

# Data characteristics
dataAttributes:
  recordCount: 50000000           # 50M companies
  updateFrequency: daily
  coverage: global
  accuracy: 95
  completeness: 85

# Pricing
prices:
  - $id: price_starter
    name: Starter
    amount: 9900
    currency: USD
    type: subscription
    interval: month
    includedRecords: 10000
    overageRate: 0.10
    description: 10K records/month, $0.10 per additional
  - $id: price_growth
    name: Growth
    amount: 29900
    currency: USD
    type: subscription
    interval: month
    includedRecords: 100000
    overageRate: 0.05
    description: 100K records/month, $0.05 per additional
  - $id: price_enterprise
    name: Enterprise
    amount: 99900
    currency: USD
    type: subscription
    interval: month
    includedRecords: 1000000
    overageRate: 0.01
    description: 1M records/month, custom overage pricing
---

# {name}

{description}

<Hero title={name} subtitle={description} />

## Dataset Overview

<DatasetStats attributes={dataAttributes} />

## Features

<Features product={$id} />

## API Access

<APIReference product={$id} />

## Pricing

<Pricing prices={prices} />

## Data Dictionary

<DataDictionary product={$id} />

interface DataProduct {
  // Identity
  id: string
  name: string
  description: string
  category: 'dataset' | 'feed' | 'api'

  // Data characteristics
  recordCount: number
  sizeGB: number
  schema: DataSchema

  // Quality metrics
  quality: DataQualityMetrics

  // Access & delivery
  accessMethods: ('api' | 'sql' | 'download' | 'warehouse')[]
  updateFrequency: 'real-time' | 'streaming' | 'daily' | 'weekly' | 'monthly'

  // Business model
  pricing: PricingModel
  licensing: LicenseTerms
}

interface Dataset {
  id: string
  name: string
  description: string
  recordCount: number
  sizeGB: number
  format: 'CSV' | 'JSON' | 'Parquet' | 'SQL'
  updateFrequency: 'real-time' | 'daily' | 'weekly' | 'monthly'
  lastUpdated: Date
  coverage: {
    geographic: string[]        // Regions/countries covered
    temporal: string            // Historical range
    completeness: number        // % of fields populated
  }
}

interface DataFeed {
  id: string
  name: string
  description: string
  frequency: 'real-time' | 'streaming' | 'batch'
  format: 'JSON' | 'XML' | 'Protobuf'
  delivery: 'webhook' | 'polling' | 'websocket'
}

interface DataAPI {
  id: string
  name: string
  description: string
  endpoints: string[]
  rateLimit: number               // Requests per minute
  queryLanguage: 'REST' | 'GraphQL' | 'SQL'
  responseFormat: 'JSON' | 'XML' | 'CSV'
}

// Marketing site for the data product
<DataSite product={dataProduct}>
  <Header />
  <LandingPage>
    <Hero />
    <DatasetOverview />
    <SampleData />
    <Pricing />
  </LandingPage>
  <APIReference />
  <DataDictionary />
  <Footer />
</DataSite>

// Data product management dashboard
<DataApp product={dataProduct}>
  <Shell>
    <Sidebar />
    <Dashboard>
      <UsageMetrics />
      <DataExplorer />
      <APIKeys />
      <Downloads />
      <Billing />
    </Dashboard>
  </Shell>
</DataApp>

interface PerRecordPricing {
  baseSubscription?: number         // Optional base fee
  pricePerRecord: number           // e.g., $0.10 per record
  includedRecords?: number         // Free tier or included quota
  tiers?: Array<{
    minRecords: number
    pricePerRecord: number
  }>
}

interface DataVolumePricing {
  pricePerGB: number               // e.g., $10 per GB
  tiers?: Array<{
    minGB: number
    pricePerGB: number
  }>
}

interface APICallPricing {
  baseSubscription: number         // $49/month
  includedCalls: number            // 10,000 calls included
  overageRate: number              // $0.01 per additional call
}

interface DataSubscriptionTiers {
  tiers: Array<{
    name: string
    price: number
    features: {
      recordsPerMonth: number
      apiCalls: number
      downloadLimit: string
      updateFrequency: string
      supportLevel: string
    }
  }>
}

interface DataQualityMetrics {
  accuracy: number                 // % of correct data
  completeness: number             // % of fields populated
  consistency: number              // % matching across sources
  timeliness: number               // % updated within SLA
  coverage: {
    geographic: string[]           // Countries/regions covered
    temporal: string               // Historical range
    scope: number                  // Total entities/records
  }
}

interface DataSchema {
  fields: Array<{
    name: string
    type: string                   // string, number, date, etc.
    description: string
    required: boolean
    format?: string
    example?: any
    coverage?: number              // % of records with this field
  }>
}

const companySchema: DataSchema = {
  fields: [
    {
      name: 'company_name',
      type: 'string',
      description: 'Legal company name',
      required: true,
      example: 'Acme Corporation',
      coverage: 100
    },
    {
      name: 'employee_count',
      type: 'number',
      description: 'Number of employees',
      required: false,
      example: 250,
      coverage: 85
    },
    {
      name: 'annual_revenue',
      type: 'number',
      description: 'Annual revenue in USD',
      required: false,
      example: 50000000,
      coverage: 60
    }
  ]
}

interface DataPipeline {
  id: string
  name: string
  description: string

  // Pipeline stages
  stages: Array<{
    name: string
    type: 'extract' | 'transform' | 'load' | 'validate' | 'enrich'
    config: Record<string, any>
  }>

  // Sources and targets
  sources: DataSource[]
  targets: DataTarget[]

  // Execution
  schedule: string              // Cron expression
  status: 'active' | 'paused' | 'error'
  lastRun: Date
  nextRun: Date

  // Monitoring
  metrics: {
    recordsProcessed: number
    duration: number
    errorRate: number
    successRate: number
  }
}

// Extract: Pull data from sources
interface ExtractStage {
  type: 'extract'
  source: {
    type: 'database' | 'api' | 'file' | 'stream'
    connection: string
    query?: string
  }
  incremental: boolean          // Only fetch new/changed records
  watermark?: string            // Track last processed record
}

// Transform: Clean, enrich, aggregate
interface TransformStage {
  type: 'transform'
  operations: Array<{
    name: string
    function: 'filter' | 'map' | 'aggregate' | 'join' | 'enrich'
    config: Record<string, any>
  }>
  validation: {
    rules: ValidationRule[]
    onError: 'skip' | 'fail' | 'quarantine'
  }
}

// Load: Deliver to destination
interface LoadStage {
  type: 'load'
  target: {
    type: 'database' | 'warehouse' | 'api' | 'file'
    connection: string
    mode: 'append' | 'replace' | 'upsert'
  }
  batchSize?: number
}

interface PipelineRun {
  id: string
  pipeline: string | Pipeline
  status: 'pending' | 'running' | 'success' | 'failed'
  startedAt: Date
  completedAt?: Date
  duration?: number

  // Metrics
  metrics: {
    recordsExtracted: number
    recordsTransformed: number
    recordsLoaded: number
    recordsSkipped: number
    recordsFailed: number
    bytesProcessed: number
  }

  // Error tracking
  errors: Array<{
    stage: string
    message: string
    count: number
    sample?: any
  }>

  // Logs
  logs: Array<{
    timestamp: Date
    level: 'info' | 'warn' | 'error'
    message: string
    metadata?: any
  }>
}

interface DataSource {
  id: string
  name: string
  type: 'database' | 'api' | 'file' | 'stream' | 'warehouse'

  // Connection
  connection: {
    host?: string
    port?: number
    database?: string
    schema?: string
    credentials: string         // Reference to secure credential store
  }

  // Configuration
  config: {
    ssl?: boolean
    timeout?: number
    poolSize?: number
    retryPolicy?: RetryPolicy
  }

  // Metadata
  tables?: string[]             // Available tables/collections
  lastSync?: Date
  status: 'connected' | 'disconnected' | 'error'
}

// Relational databases
type SQLDatabase = 'postgres' | 'mysql' | 'mssql' | 'oracle' | 'sqlite'

// NoSQL databases
type NoSQLDatabase = 'mongodb' | 'cassandra' | 'redis' | 'dynamodb'

// Cloud data warehouses
type Warehouse = 'snowflake' | 'bigquery' | 'redshift' | 'databricks'

interface DatabaseConnector {
  type: SQLDatabase | NoSQLDatabase | Warehouse
  connection: ConnectionConfig
  queryTimeout: number
  maxConnections: number

  // Methods
  connect(): Promise<void>
  disconnect(): Promise<void>
  query(sql: string): Promise<any[]>
  stream(sql: string): AsyncIterator<any>
}

interface SQLInterface {
  enabled: boolean
  dialect: 'postgres' | 'mysql' | 'standard'
  endpoint: string              // JDBC/ODBC connection string
  authentication: 'basic' | 'token' | 'certificate'

  // Query capabilities
  features: {
    joins: boolean
    aggregations: boolean
    windowFunctions: boolean
    ctes: boolean               // Common Table Expressions
  }

  // Limits
  maxQueryDuration: number
  maxResultSize: number
  maxConcurrentQueries: number
}

// Example usage
const connection = createConnection({
  host: 'data.acme.com',
  port: 5432,
  database: 'company_data',
  user: 'api_key_xxx',
  password: 'api_secret_xxx'
})

const results = await connection.query(`
  SELECT company_name, industry, employee_count
  FROM companies
  WHERE industry = 'Technology'
    AND employee_count > 100
  ORDER BY employee_count DESC
  LIMIT 100
`)

interface GraphQLInterface {
  enabled: boolean
  endpoint: string
  schema: string                // GraphQL SDL

  // Features
  features: {
    filtering: boolean
    sorting: boolean
    pagination: boolean
    aggregations: boolean
  }

  // Limits
  maxDepth: number
  maxComplexity: number
}

// Example query
query GetCompanies($industry: String!) {
  companies(
    where: { industry: { eq: $industry } }
    orderBy: { employeeCount: DESC }
    limit: 100
  ) {
    edges {
      node {
        name
        industry
        employeeCount
        location {
          city
          country
        }
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

interface Authentication {
  // API Key (most common)
  apiKey: {
    enabled: boolean
    prefix: string              // e.g., 'acme_'
    rotation: boolean           // Allow key rotation
    expiresAfter?: number       // Days until expiration
  }

  // OAuth 2.0
  oauth: {
    enabled: boolean
    flows: ('client_credentials' | 'authorization_code')[]
    scopes: string[]
  }

  // JWT tokens
  jwt: {
    enabled: boolean
    issuer: string
    audience: string
    algorithm: 'RS256' | 'HS256'
  }

  // IP whitelist
  ipWhitelist: {
    enabled: boolean
    allowedIPs: string[]
  }
}

interface AccessControl {
  // Role-based access control
  roles: Array<{
    name: string
    permissions: Permission[]
    dataAccess: DataAccessRule[]
  }>

  // Permissions
  permissions: {
    read: boolean
    write: boolean
    export: boolean
    admin: boolean
  }

  // Row-level security
  rowLevelSecurity: {
    enabled: boolean
    rules: Array<{
      field: string
      operator: 'equals' | 'in' | 'not_in'
      value: any
    }>
  }

  // Field-level security
  fieldLevelSecurity: {
    enabled: boolean
    hiddenFields: string[]      // Fields to hide from this user
    maskedFields: Array<{
      field: string
      maskType: 'partial' | 'hash' | 'redact'
    }>
  }
}

interface UsageLimits {
  // API rate limits
  rateLimit: {
    requestsPerSecond: number
    requestsPerDay: number
    requestsPerMonth: number
    burstLimit: number
  }

  // Data volume limits
  dataLimits: {
    recordsPerQuery: number
    recordsPerDay: number
    recordsPerMonth: number
    bytesPerMonth: number
  }

  // Overage handling
  overage: {
    allowed: boolean
    rate: number                // Price per additional unit
    maxOverage?: number         // Maximum overage allowed
  }

  // Throttling behavior
  throttling: {
    mode: 'hard' | 'soft'       // Hard: reject, Soft: queue
    queueSize?: number
    backoffStrategy: 'linear' | 'exponential'
  }
}

interface AuditLog {
  id: string
  timestamp: Date

  // Who
  user: {
    id: string
    email: string
    apiKey: string
  }

  // What
  action: 'query' | 'export' | 'access' | 'delete'
  resource: string
  query?: string

  // Result
  status: 'success' | 'denied' | 'error'
  recordsAccessed: number
  bytesTransferred: number
  duration: number

  // Context
  metadata: {
    ipAddress: string
    userAgent: string
    location?: string
  }
}

interface MarketplaceListing {
  // Product info
  product: string | Product
  title: string
  shortDescription: string      // 160 chars for search results
  longDescription: string        // Full product description

  // Discovery
  categories: string[]           // Primary categorization
  tags: string[]                 // Searchable keywords
  industries: string[]           // Target industries
  useCases: string[]             // Common use cases

  // Media
  logo: string                   // Product logo
  screenshots: string[]          // Product screenshots
  video?: string                 // Demo video URL

  // Samples
  sampleData: {
    url: string
    format: 'CSV' | 'JSON'
    recordCount: number
  }
  documentation: string          // Docs URL
  apiReference: string           // API reference URL

  // Pricing
  pricingModel: string           // Clear pricing description
  freeTier: boolean              // Has free tier
  trialAvailable: boolean        // Offers trial

  // Social proof
  customers: number              // Customer count
  rating: number                 // Average rating (1-5)
  reviews: number                // Number of reviews
  featured: boolean              // Featured listing
}

interface DataProductCatalog {
  // Catalog metadata
  name: string
  description: string

  // Products
  products: Array<{
    id: string
    name: string
    category: string
    pricing: {
      startingAt: number
      currency: string
      model: 'subscription' | 'usage' | 'one-time'
    }
    metadata: {
      recordCount: number
      updateFrequency: string
      coverage: string
    }
    featured: boolean
  }>

  // Filtering
  filters: {
    categories: string[]
    industries: string[]
    priceRange: { min: number; max: number }
    dataTypes: string[]
  }

  // Search
  search: {
    query: string
    fields: string[]              // Fields to search
    fuzzy: boolean
  }
}

interface MarketplaceIntegration {
  // Platform
  platform: 'snowflake' | 'aws_data_exchange' | 'databricks' | 'custom'

  // Listing
  listingId: string
  status: 'draft' | 'published' | 'unlisted'
  publishedAt?: Date

  // Distribution
  distribution: {
    autoProvision: boolean       // Auto-provision on purchase
    accessMethod: 'share' | 'copy' | 'api'
    region: string[]             // Available regions
  }

  // Revenue
  revenueShare: number           // % platform takes
  payoutSchedule: 'daily' | 'weekly' | 'monthly'

  // Analytics
  analytics: {
    views: number
    trials: number
    purchases: number
    revenue: number
  }
}

# Query company data
GET https://api.acme.com/v1/companies?domain=example.com

# Bulk export
POST https://api.acme.com/v1/export
{
  "filters": { "industry": "SaaS", "employees": { "gte": 50 } },
  "fields": ["name", "domain", "employees", "revenue"],
  "format": "CSV"
}

-- Direct SQL access to data warehouse
SELECT
  company_name,
  industry,
  employee_count,
  annual_revenue
FROM acme.companies
WHERE
  industry = 'Technology'
  AND employee_count BETWEEN 50 AND 500
ORDER BY annual_revenue DESC
LIMIT 1000;

interface DataDownload {
  id: string
  format: 'CSV' | 'JSON' | 'Parquet' | 'Excel'
  compression: 'gzip' | 'zip' | 'none'
  filters: Record<string, any>
  status: 'pending' | 'processing' | 'ready' | 'expired'
  url?: string                     // Download URL when ready
  expiresAt?: Date
}

// Request export
const download = await client.exports.create({
  dataset: 'companies',
  format: 'CSV',
  filters: { industry: 'SaaS' },
  compression: 'gzip'
});

// Download when ready
await download.download('./companies.csv.gz');

interface WarehouseConnector {
  platform: 'Snowflake' | 'BigQuery' | 'Redshift' | 'Databricks'
  connection: {
    host: string
    database: string
    schema: string
    credentials: string
  }
  syncSchedule: string             // Cron expression
  tables: string[]
}

product: B2B Contact Database
type: Data

dataset:
  - 50M companies
  - 200M contacts
  - Firmographic data
  - Technographic data

use_case: Sales prospecting and lead enrichment

pricing:
  - $99/month: 1,000 enrichments
  - $499/month: 10,000 enrichments
  - $2,499/month: 100,000 enrichments

features:
  - Company search and filtering
  - Contact data enrichment
  - Technographic intelligence
  - Real-time API access
  - CSV exports

product: Industry Analytics Platform
type: Data

dataset:
  - 10 years historical data
  - 50+ industries
  - 200+ metrics per company

use_case: Market sizing and competitive analysis

pricing:
  - Basic: $199/month (1 industry)
  - Pro: $999/month (5 industries)
  - Enterprise: $4,999/month (all industries)

features:
  - Industry benchmarks
  - Trend analysis
  - Competitive intelligence
  - Custom reports
  - API + SQL access

product: Market Data Platform
type: Data

dataset:
  - Real-time stock prices
  - Historical OHLCV data
  - 50,000+ securities
  - Options and futures

use_case: Trading algorithms and portfolio management

pricing:
  - $49/month: Delayed data (15 min)
  - $299/month: Real-time data
  - $1,499/month: Real-time + options

features:
  - WebSocket streaming
  - REST API
  - Historical downloads
  - Corporate actions
  - Earnings data

// Datasets collection
interface DatasetRecord {
  id: string
  product: string | Product
  name: string
  recordCount: number
  lastUpdated: Date
  schema: DataSchema
  sampleData: any[]
}

// Data access logs
interface DataAccessLog {
  id: string
  customer: string | Customer
  dataset: string | Dataset
  recordsAccessed: number
  apiCalls: number
  bytesTransferred: number
  timestamp: Date
}

// Track data consumption for billing
interface DataUsage {
  customer: string | Customer
  period: { start: Date; end: Date }
  metrics: {
    recordsAccessed: number
    apiCalls: number
    gbDownloaded: number
    queriesExecuted: number
  }
  charges: {
    subscription: number
    overageRecords: number
    overageAPI: number
    overageDownload: number
    total: number
  }
}

# Product Identity
$id: https://acme.com/products/company-iq
$type: Product
name: CompanyIQ
type: Data
description: B2B company intelligence and enrichment API

# Data Characteristics
dataAttributes:
  recordCount: 50000000         # 50M companies
  updateFrequency: daily
  coverage: global
  accuracy: 95                  # 95% accuracy
  completeness: 85              # 85% field completeness

# Data Schema
schema:
  fields:
    - name: company_name
      type: string
      required: true
      coverage: 100
    - name: domain
      type: string
      required: true
      coverage: 100
    - name: industry
      type: string
      required: false
      coverage: 92
    - name: employee_count
      type: number
      required: false
      coverage: 85
    - name: annual_revenue
      type: number
      required: false
      coverage: 60

# Access Methods
interfaces:
  hasAPI: true                  # REST API
  hasSQL: true                  # SQL access
  hasDownload: true             # CSV/JSON downloads
  hasMCP: true                  # AI agent access

# Access Control
authentication:
  apiKey:
    enabled: true
    prefix: "ciq_"
    rotation: true
  ipWhitelist:
    enabled: true
    allowedIPs: []

authorization:
  rateLimit:
    requestsPerSecond: 10
    requestsPerDay: 10000
    requestsPerMonth: 300000
  dataLimits:
    recordsPerQuery: 1000
    recordsPerMonth: 100000

# Pricing Tiers
prices:
  - $id: price_starter
    name: Starter
    amount: 9900                # $99/month
    currency: USD
    type: subscription
    interval: month
    includedRecords: 10000
    overageRate: 0.10           # $0.10 per additional

  - $id: price_growth
    name: Growth
    amount: 29900               # $299/month
    currency: USD
    type: subscription
    interval: month
    includedRecords: 100000
    overageRate: 0.05           # $0.05 per additional

  - $id: price_enterprise
    name: Enterprise
    amount: 99900               # $999/month
    currency: USD
    type: subscription
    interval: month
    includedRecords: 1000000
    overageRate: 0.01           # $0.01 per additional
    features:
      - Dedicated support
      - Custom data feeds
      - SLA guarantee
      - On-premise deployment option

# Data Pipeline
pipeline:
  sources:
    - type: database
      name: Primary DB
      connection: postgres://internal-db
    - type: api
      name: External Enrichment
      connection: https://partner-api.com

  stages:
    - name: Extract
      type: extract
      schedule: "0 2 * * *"      # Daily at 2am
    - name: Transform
      type: transform
      operations:
        - function: deduplicate
          field: domain
        - function: validate
          rules:
            - field: domain
              rule: is_valid_domain
        - function: enrich
          source: external_api
    - name: Load
      type: load
      target: production_db
      mode: upsert

# Marketplace
marketplace:
  platforms:
    - platform: snowflake
      listingId: acme_company_iq
      status: published
    - platform: aws_data_exchange
      listingId: company-iq-dataset
      status: published

  metadata:
    categories:
      - B2B Data
      - Sales Intelligence
      - Company Information
    tags:
      - firmographic
      - company data
      - b2b
      - enrichment
    industries:
      - SaaS
      - Sales & Marketing
      - Financial Services

    samples:
      - url: https://acme.com/samples/company-iq.csv
        format: CSV
        recordCount: 1000

name: EmailGraph
type: Data
description: Email validation and intelligence platform

data_points:
  - Email validity
  - Deliverability score
  - Domain reputation
  - Person name and title
  - Company information
  - Social profiles

coverage:
  - Real-time validation
  - 2B+ email addresses
  - 99% accuracy

pricing:
  - $0.001 per validation
  - $0.10 per enrichment
  - API + bulk file processing

name: GeoData Pro
type: Data
description: Global location and POI database

data_points:
  - Points of interest (POI)
  - Business locations
  - Geographic boundaries
  - Demographics by area
  - Traffic patterns

coverage:
  - 200M+ POIs
  - 195 countries
  - Updated weekly

pricing:
  - $199/month: 10K API calls
  - $999/month: 100K API calls
  - Enterprise: Unlimited access