Capability Contracts API Reference¶

All capability contracts are in the io.patternops.capabilities package and extend BaseProviderContract.

Base Contract¶

// io.patternops.core.contract.BaseProviderContract
public interface BaseProviderContract {
    ValidationResult validateConfig(Map<String, Object> config);
    void initialise(Map<String, Object> config);
    HealthStatus healthCheck();
    List<MetricsEnvelope> metrics();
    void cleanup();
}

Source Acquisition¶

Package: io.patternops.capabilities.source

public interface SourceAcquisitionContract extends BaseProviderContract {
    ConnectionResult connect();
    SchemaDescriptor discoverSchema();
    DataStream acquire(String mode, Map<String, Object> parameters);
    CheckpointState checkpoint();
    DataStream resume(CheckpointState checkpoint);
    void disconnect();
}

Execution¶

Package: io.patternops.capabilities.execution

public interface ExecutionContract extends BaseProviderContract {
    ValidationResult validatePipeline(Pipeline pipeline);
    SubmissionResult submit(Pipeline pipeline, Map<String, Object> parameters);
    ExecutionStatus status(String executionId);
    CancellationResult cancel(String executionId);
    List<MetricsEnvelope> executionMetrics(String executionId);
    List<StructuredLogEntry> logs(String executionId);
}

Orchestration¶

Package: io.patternops.capabilities.orchestration

public interface OrchestrationContract extends BaseProviderContract {
    SubmissionResult submit(String pipelineId, Map<String, Object> schedule);
    void schedule(String pipelineId, String cronExpression);
    void retry(String executionId, Map<String, Object> strategy);
    void cancel(String executionId);
    void pause(String executionId);
    void resume(String executionId);
    ObservationResult observe(String executionId);
    void recover(String executionId, String recoveryPoint);
}

Messaging¶

Package: io.patternops.capabilities.messaging

public interface MessagingContract extends BaseProviderContract {
    void publish(Object event);
    Object consume(String subscription);
    void acknowledge(String eventId);
    void deadLetter(Object event, String reason);
    void replay(String subscription, String fromPosition);
    Map<String, Object> messagingMetrics(String subscription);
}

State Management¶

Package: io.patternops.capabilities.state

public interface StateManagementContract extends BaseProviderContract {
    void write(String key, Object state);
    Object read(String key);
    List<Object> query(Map<String, Object> filter);
    void delete(String key);
    void checkpoint(String executionId);
    void restore(String executionId, String checkpointId);
}

Storage¶

Package: io.patternops.capabilities.storage

public interface StorageContract extends BaseProviderContract {
    void write(String path, Object data, Map<String, Object> options);
    Object read(String path, Map<String, Object> options);
    List<String> list(String prefix, Map<String, Object> options);
    void commit(String transactionId);
    ValidationResult validatePath(String path);
    void applyRetention(String path, Map<String, Object> policy);
    void applySecurity(String path, Map<String, Object> policy);
}

Replication¶

Package: io.patternops.capabilities.replication

public interface ReplicationContract extends BaseProviderContract {
    ReplicationResult replicate(String source, String destination, Map<String, Object> options);
    void synchronise(String source, String destination);
    VerificationResult verify(String source, String destination);
    void resume(String replicationId, Object checkpoint);
    MonitorResult monitor(String replicationId);
}

Security Sub-Capabilities¶

Package: io.patternops.capabilities.security

public interface ClassificationContract extends BaseProviderContract {
    ClassificationResult classify(String fieldId, Object value);
    void tag(String fieldId, String classification);
    RiskScore scoreRisk(String fieldId);
}

public interface EncryptionContract extends BaseProviderContract {
    EncryptionResult encrypt(byte[] data, String keyReference);
    byte[] decrypt(byte[] ciphertext, String keyReference);
    void rotateKeys(String keyReference);
}

public interface TokenisationContract extends BaseProviderContract {
    String tokenise(String sensitiveValue);
    String detokenise(String token);
    boolean validate(String token);
}

public interface SecretManagementContract extends BaseProviderContract {
    String resolveSecret(String secretId);
    void rotateSecret(String secretId);
    boolean validateAccess(String secretId, String principal);
}

Data Quality¶

Package: io.patternops.capabilities.quality

public interface DataQualityContract extends BaseProviderContract {
    Object profile(String dataset, Map<String, Object> options);
    Object validate(String dataset, List<Object> rules);
    Object monitor(String dataset, Object baseline);
    Object trend(String dataset, String metric, Object timeRange);
    Object detectAnomaly(String dataset, String metric, double sensitivity);
}

Transformation¶

Package: io.patternops.capabilities.transformation

public interface TransformationContract extends BaseProviderContract {
    ValidationResult validateTransformation(TransformationDefinition definition);
    ExecutionResult execute(TransformationDefinition definition, String inputRef, String outputRef);
    Explanation explain(TransformationDefinition definition);
    FieldLevelLineage lineage(TransformationDefinition definition);
    TransformationDefinition optimise(TransformationDefinition definition);
}

Observability¶

Package: io.patternops.capabilities.observability

public interface ObservabilityContract extends BaseProviderContract {
    void exportTraces(List<Object> spans);
    void exportMetrics(List<MetricsEnvelope> metrics);
    void exportLogs(List<Object> logs);
    Object healthStatus();
    void configureAlerts(List<Object> rules);
}

Lineage¶

Package: io.patternops.capabilities.lineage

public interface LineageContract extends BaseProviderContract {
    void emitLineage(LineageEvent event);
    void publishLineage(LineageEvent event);
    Object queryLineage(String dataset, String direction);
    Object exportLineage(String format);
}

Data Contract¶

Package: io.patternops.capabilities.datacontract

public interface DataContractContract extends BaseProviderContract {
    Object generateContract(Pipeline pipeline, Object outputSchema);
    ValidationResult validateContract(Object contract);
    Object publishContract(Object contract, Object version);
    Object checkCompatibility(Object existing, Object proposed);
    void deprecateContract(String contractId, Object version);
}

Version Control¶

Package: io.patternops.capabilities.versioncontrol

public interface VersionControlContract extends BaseProviderContract {
    Object commit(String artifactType, String artifactId, Object content, String message, String author);
    Object getVersion(String artifactType, String artifactId, int version);
    Object getLatest(String artifactType, String artifactId);
    List<Object> listVersions(String artifactType, String artifactId);
    Object diff(String artifactType, String artifactId, int versionA, int versionB);
    Object rollback(String artifactType, String artifactId, int targetVersion);
    void tag(String artifactType, String artifactId, int version, String tagName);
}

Extension¶

Package: io.patternops.capabilities.extension

public interface ExtensionContract extends BaseProviderContract {
    Object execute(String hookType, Map<String, Object> parameters);
    ValidationResult validateExtension(String hookType, Map<String, Object> config);
    List<String> supportedHookTypes();
}

Supported hook types: Python, Shell, Container, Java, Scala, Remote API, MCP Tool.