services-as-software/dist/index.d.ts

Define services with objectives, key results, and various pricing models

import { Objective as Objective$1, KeyResult as KeyResult$1 } from 'business-as-code';

/**
 * Pricing model types for services
 */
type PricingModel = 'cost-based' | 'margin-based' | 'activity-based' | 'outcome-based';
/**
 * Cost-based pricing configuration
 */
interface CostBasedPricing {
    model: 'cost-based';
    costBase: number;
    fixedCosts?: number;
    variableCosts?: number;
}
/**
 * Margin-based pricing configuration
 */
interface MarginBasedPricing {
    model: 'margin-based';
    costBase: number;
    marginPercentage: number;
}
/**
 * Activity-based pricing configuration
 */
interface ActivityBasedPricing {
    model: 'activity-based';
    activities: {
        name: string;
        description?: string;
        rate: number;
    }[];
}
/**
 * Outcome-based pricing configuration
 */
interface OutcomeBasedPricing {
    model: 'outcome-based';
    outcomes: {
        metric: string;
        description?: string;
        targetValue: number;
        price: number;
        unit?: string;
    }[];
}
/**
 * Union type for all pricing configurations
 */
type ServicePricing = CostBasedPricing | MarginBasedPricing | ActivityBasedPricing | OutcomeBasedPricing;
/**
 * Implementation types for services
 */
type ImplementationType = 'function' | 'workflow' | 'agent';
/**
 * Implementation details for a service
 */
interface ImplementationDetails {
    type: ImplementationType;
    id: string;
    version?: string;
    configuration?: Record<string, any>;
}
/**
 * Service definition with business model aspects
 */
interface ServiceDefinition {
    /**
     * Service name
     */
    name: string;
    /**
     * Service description
     */
    description?: string;
    /**
     * Service objective
     */
    objective: Objective$1;
    /**
     * Key results for measuring service success
     */
    keyResults: KeyResult$1[];
    /**
     * Service pricing model
     */
    pricing: ServicePricing;
    /**
     * Implementation details
     */
    implementation: ImplementationDetails;
    /**
     * Additional metadata
     */
    metadata?: Record<string, any>;
}
/**
 * Registered service with additional properties
 */
interface RegisteredService extends ServiceDefinition {
    /**
     * Unique service identifier
     */
    id: string;
    /**
     * Service status
     */
    status: 'active' | 'inactive' | 'degraded';
    /**
     * Service endpoint URL
     */
    endpoint: string;
    /**
     * Creation timestamp
     */
    createdAt: string;
    /**
     * Last update timestamp
     */
    updatedAt: string;
}

interface Objective {
    description: string;
    keyResults: string[] | KeyResult[];
}
interface KeyResult {
    description: string;
    target?: number;
    currentValue?: number;
    unit?: string;
    dueDate?: Date;
}

/**
 * Calculate price for cost-based pricing model
 * @param pricing Cost-based pricing configuration
 * @param quantity Number of units
 * @returns Calculated price
 */
declare function calculateCostBasedPrice(pricing: CostBasedPricing, quantity?: number): number;
/**
 * Calculate price for margin-based pricing model
 * @param pricing Margin-based pricing configuration
 * @param quantity Number of units
 * @returns Calculated price
 */
declare function calculateMarginBasedPrice(pricing: MarginBasedPricing, quantity?: number): number;
/**
 * Calculate price for activity-based pricing model
 * @param pricing Activity-based pricing configuration
 * @param activities Record of activity names and their quantities
 * @returns Calculated price
 */
declare function calculateActivityBasedPrice(pricing: ActivityBasedPricing, activities: Record<string, number>): number;
/**
 * Calculate price for outcome-based pricing model
 * @param pricing Outcome-based pricing configuration
 * @param outcomes Record of metric names and their achieved values
 * @returns Calculated price
 */
declare function calculateOutcomeBasedPrice(pricing: OutcomeBasedPricing, outcomes: Record<string, number>): number;
/**
 * Calculate price based on the pricing model
 * @param pricing Service pricing configuration
 * @param params Additional parameters for price calculation
 * @returns Calculated price
 */
declare function calculatePrice(pricing: ServicePricing, params?: {
    quantity?: number;
    activities?: Record<string, number>;
    outcomes?: Record<string, number>;
}): number;

/**
 * Create a service with objectives, key results, and pricing models
 * @param definition Service definition
 * @returns Service object with additional methods
 */
declare function Service(definition: ServiceDefinition): {
    /**
     * Calculate the price for this service
     * @param params Parameters for price calculation
     * @returns Calculated price
     */
    calculatePrice(params?: Parameters<typeof calculatePrice>[1]): number;
    /**
     * Register the service with the service registry
     * @param options Optional configuration for service registration
     * @returns Promise resolving to the registered service
     */
    register(options?: {
        apiKey?: string;
        baseUrl?: string;
    }): Promise<RegisteredService>;
    /**
     * Track progress towards key results
     * @param results Record of key result updates
     */
    trackProgress(results: Record<string, number>): void;
    /**
     * Check if all key results have been achieved
     * @returns Whether all key results have been achieved
     */
    isObjectiveAchieved(): boolean;
    name: string;
    description?: string;
    objective: Objective;
    keyResults: KeyResult[];
    pricing: ServicePricing;
    implementation: ImplementationDetails;
    metadata?: Record<string, any>;
};

export { type ActivityBasedPricing, type CostBasedPricing, type ImplementationDetails, type ImplementationType, type MarginBasedPricing, type OutcomeBasedPricing, type PricingModel, type RegisteredService, Service, type ServiceDefinition, type ServicePricing, calculateActivityBasedPrice, calculateCostBasedPrice, calculateMarginBasedPrice, calculateOutcomeBasedPrice, calculatePrice };