/**
 * PEAC Obligations Extension Types (v0.9.26+)
 *
 * Defines credit and contribution obligations for receipts,
 * aligned with Creative Commons Signals framework.
 *
 * The `peac/obligations` extension allows content owners to specify
 * requirements for credit/attribution and contribution models.
 *
 * @see https://creativecommons.org/signals/ for CC Signals background
 */
import { z } from 'zod';
/**
 * How credit/attribution should be provided.
 *
 * - 'inline': Credit appears inline with the generated content
 * - 'references': Credit appears in a references/sources section
 * - 'model-card': Credit appears in model documentation/card
 */
export declare const CreditMethodSchema: z.ZodEnum<{
    inline: "inline";
    references: "references";
    "model-card": "model-card";
}>;
export type CreditMethod = z.infer<typeof CreditMethodSchema>;
/**
 * Array of valid credit methods for runtime checks.
 */
export declare const CREDIT_METHODS: readonly ["inline", "references", "model-card"];
/**
 * Type of contribution model.
 *
 * - 'direct': Direct payment to content owner
 * - 'ecosystem': Contribution to ecosystem fund/coalition
 * - 'open': Freely usable (no payment required)
 */
export declare const ContributionTypeSchema: z.ZodEnum<{
    direct: "direct";
    open: "open";
    ecosystem: "ecosystem";
}>;
export type ContributionType = z.infer<typeof ContributionTypeSchema>;
/**
 * Array of valid contribution types for runtime checks.
 */
export declare const CONTRIBUTION_TYPES: readonly ["direct", "ecosystem", "open"];
/**
 * CreditObligation - specifies attribution/credit requirements.
 *
 * Content owners can require credit when their content is used,
 * specifying where and how the credit should appear.
 *
 * @example
 * ```typescript
 * const credit: CreditObligation = {
 *   required: true,
 *   citation_url: 'https://publisher.example/collection',
 *   method: 'references',
 * };
 * ```
 */
export declare const CreditObligationSchema: z.ZodObject<{
    required: z.ZodBoolean;
    citation_url: z.ZodOptional<z.ZodString>;
    method: z.ZodOptional<z.ZodEnum<{
        inline: "inline";
        references: "references";
        "model-card": "model-card";
    }>>;
    credit_text: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export type CreditObligation = z.infer<typeof CreditObligationSchema>;
/**
 * ContributionObligation - specifies contribution/payment model.
 *
 * Aligned with CC Signals reciprocity framework:
 * - direct: Payment goes directly to content owner
 * - ecosystem: Payment goes to shared ecosystem fund
 * - open: Content is freely usable
 *
 * @example
 * ```typescript
 * const contribution: ContributionObligation = {
 *   type: 'ecosystem',
 *   destination: 'https://fund.creativecommons.org',
 * };
 * ```
 */
export declare const ContributionObligationSchema: z.ZodObject<{
    type: z.ZodEnum<{
        direct: "direct";
        open: "open";
        ecosystem: "ecosystem";
    }>;
    destination: z.ZodOptional<z.ZodString>;
    min_amount: z.ZodOptional<z.ZodNumber>;
    currency: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export type ContributionObligation = z.infer<typeof ContributionObligationSchema>;
/**
 * Extension key for obligations
 */
export declare const OBLIGATIONS_EXTENSION_KEY: "peac/obligations";
/**
 * ObligationsExtension - the full obligations extension block.
 *
 * This extension is added to receipt extensions under the key `peac/obligations`.
 *
 * @example
 * ```typescript
 * const receipt = {
 *   // ... receipt fields ...
 *   extensions: {
 *     'peac/obligations': {
 *       credit: {
 *         required: true,
 *         citation_url: 'https://publisher.example/collection',
 *         method: 'references',
 *       },
 *       contribution: {
 *         type: 'ecosystem',
 *         destination: 'https://fund.example.org',
 *       },
 *     },
 *   },
 * };
 * ```
 */
export declare const ObligationsExtensionSchema: z.ZodObject<{
    credit: z.ZodOptional<z.ZodObject<{
        required: z.ZodBoolean;
        citation_url: z.ZodOptional<z.ZodString>;
        method: z.ZodOptional<z.ZodEnum<{
            inline: "inline";
            references: "references";
            "model-card": "model-card";
        }>>;
        credit_text: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    contribution: z.ZodOptional<z.ZodObject<{
        type: z.ZodEnum<{
            direct: "direct";
            open: "open";
            ecosystem: "ecosystem";
        }>;
        destination: z.ZodOptional<z.ZodString>;
        min_amount: z.ZodOptional<z.ZodNumber>;
        currency: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ObligationsExtension = z.infer<typeof ObligationsExtensionSchema>;
/**
 * Validate a CreditObligation.
 *
 * @param data - Unknown data to validate
 * @returns Result with validated obligation or error message
 */
export declare function validateCreditObligation(data: unknown): {
    ok: true;
    value: CreditObligation;
} | {
    ok: false;
    error: string;
};
/**
 * Validate a ContributionObligation.
 *
 * @param data - Unknown data to validate
 * @returns Result with validated obligation or error message
 */
export declare function validateContributionObligation(data: unknown): {
    ok: true;
    value: ContributionObligation;
} | {
    ok: false;
    error: string;
};
/**
 * Validate an ObligationsExtension.
 *
 * @param data - Unknown data to validate
 * @returns Result with validated extension or error message
 *
 * @example
 * ```typescript
 * const result = validateObligationsExtension(data);
 * if (result.ok) {
 *   if (result.value.credit?.required) {
 *     console.log('Credit required:', result.value.credit.citation_url);
 *   }
 * }
 * ```
 */
export declare function validateObligationsExtension(data: unknown): {
    ok: true;
    value: ObligationsExtension;
} | {
    ok: false;
    error: string;
};
/**
 * Extract obligations extension from a receipt's extensions object.
 *
 * @param extensions - Extensions object from receipt
 * @returns Validated obligations or undefined if not present
 */
export declare function extractObligationsExtension(extensions: Record<string, unknown> | undefined): ObligationsExtension | undefined;
/**
 * Check if credit is required based on obligations.
 *
 * @param obligations - Obligations extension
 * @returns True if credit is explicitly required
 */
export declare function isCreditRequired(obligations: ObligationsExtension | undefined): boolean;
/**
 * Check if contribution is required (non-open type).
 *
 * @param obligations - Obligations extension
 * @returns True if contribution type is 'direct' or 'ecosystem'
 */
export declare function isContributionRequired(obligations: ObligationsExtension | undefined): boolean;
/**
 * Create a credit-only obligations extension.
 *
 * @param params - Credit parameters
 * @returns ObligationsExtension with credit only
 */
export declare function createCreditObligation(params: {
    required: boolean;
    citation_url?: string;
    method?: CreditMethod;
    credit_text?: string;
}): ObligationsExtension;
/**
 * Create a contribution-only obligations extension.
 *
 * @param params - Contribution parameters
 * @returns ObligationsExtension with contribution only
 */
export declare function createContributionObligation(params: {
    type: ContributionType;
    destination?: string;
    min_amount?: number;
    currency?: string;
}): ObligationsExtension;
/**
 * Create a full obligations extension with both credit and contribution.
 *
 * @param credit - Credit obligation parameters
 * @param contribution - Contribution obligation parameters
 * @returns Full ObligationsExtension
 */
export declare function createObligationsExtension(credit?: {
    required: boolean;
    citation_url?: string;
    method?: CreditMethod;
    credit_text?: string;
}, contribution?: {
    type: ContributionType;
    destination?: string;
    min_amount?: number;
    currency?: string;
}): ObligationsExtension;
//# sourceMappingURL=obligations.d.ts.map