/**
 * File was automatically generated using json-schema-to-typescript.
 * DO NOT MODIFY IT BY HAND.
 * Instead, modify the source file https://formats.openag.io/oada/ainz/rule.schema.json of @oada/formats
 * and run `$ yarn build` to regenerate this file.
 */
/**
 * $id of the source schema
 * @see {@link https://formats.openag.io/oada/ainz/rule.schema.json}
 */
export declare const $id = "https://formats.openag.io/oada/ainz/rule.schema.json";
/**
 * Returns true if val is a @type Rule, false otherwise
 */
export declare function is(val: any): val is Rule;
/**
 * Asserts that val is a @type Rule
 */
export declare function assert(val: any): asserts val is Rule;
export default Rule;
/**
 * The format for ainz orchestation rules
 */
export declare type Rule = {
    /**
     * A field for discriminating the different types of rules
     */
    type: "reindex";
    /**
     * A path to an OADA list to which to add maching items
     */
    destination?: string;
    /**
     * And object to PUT on matching items's _meta
     */
    meta?: {
        [k: string]: unknown;
    };
    /**
     * A path to an OADA list to watch for changes
     */
    list: string;
    schema: CoreAndValidationSpecificationsMetaSchema;
    [k: string]: unknown;
} | {
    /**
     * A field for discriminating the different types of rules
     */
    type: "job";
    /**
     * A JSON pointer of where in the job config to create a link to the resource
     */
    pointer?: string;
    /**
     * The job to create. A link to the matching resource will be added to the job.
     */
    job?: {
        /**
         * Service name which job is for
         */
        service: string;
        /**
         * Service specific identifier of job type
         */
        type: string;
        /**
         * Job spceific configuration object
         */
        config?: {
            [k: string]: unknown;
        };
        /**
         * Final result of job
         */
        result?: {
            [k: string]: unknown;
        };
        /**
         * Current status of job
         */
        status?: string;
        /**
         * A list of updates as job progresses. Keys shall be sorted in time order.
         */
        updates?: {
            /**
             * A list of updates as job progresses. Keys shall be sorted in time order.
             */
            [k: string]: {
                /**
                 * Status of job at the time of update
                 */
                status: string;
                /**
                 * ISO8601 UTC date-time of update time
                 */
                time: string;
                /**
                 * Additional meta data about the status update
                 */
                meta?: {
                    [k: string]: unknown;
                };
                [k: string]: unknown;
            };
        };
        [k: string]: unknown;
    };
    /**
     * A path to an OADA list to watch for changes
     */
    list: string;
    schema: CoreAndValidationSpecificationsMetaSchema1;
    [k: string]: unknown;
};
/**
 * A JSON Schema to which to compare new items in list
 */
export declare type CoreAndValidationSpecificationsMetaSchema = CoreVocabularyMetaSchema2 & ApplicatorVocabularyMetaSchema2 & ValidationVocabularyMetaSchema2 & MetaDataVocabularyMetaSchema2 & FormatVocabularyMetaSchema2 & ContentVocabularyMetaSchema2;
export declare type CoreVocabularyMetaSchema2 = CoreVocabularyMetaSchema | CoreVocabularyMetaSchema1;
export declare type CoreVocabularyMetaSchema1 = boolean;
export declare type ApplicatorVocabularyMetaSchema2 = ApplicatorVocabularyMetaSchema | ApplicatorVocabularyMetaSchema1;
export declare type ApplicatorVocabularyMetaSchema1 = boolean;
export declare type ValidationVocabularyMetaSchema2 = ValidationVocabularyMetaSchema | ValidationVocabularyMetaSchema1;
export declare type ValidationVocabularyMetaSchema1 = boolean;
export declare type MetaDataVocabularyMetaSchema2 = MetaDataVocabularyMetaSchema | MetaDataVocabularyMetaSchema1;
export declare type MetaDataVocabularyMetaSchema1 = boolean;
export declare type FormatVocabularyMetaSchema2 = FormatVocabularyMetaSchema | FormatVocabularyMetaSchema1;
export declare type FormatVocabularyMetaSchema1 = boolean;
export declare type ContentVocabularyMetaSchema2 = ContentVocabularyMetaSchema | ContentVocabularyMetaSchema1;
export declare type ContentVocabularyMetaSchema1 = boolean;
/**
 * A JSON Schema to which to compare new items in list
 */
export declare type CoreAndValidationSpecificationsMetaSchema1 = CoreVocabularyMetaSchema2 & ApplicatorVocabularyMetaSchema2 & ValidationVocabularyMetaSchema2 & MetaDataVocabularyMetaSchema2 & FormatVocabularyMetaSchema2 & ContentVocabularyMetaSchema2;
export interface CoreVocabularyMetaSchema {
    $id?: string;
    $schema?: string;
    $anchor?: string;
    $ref?: string;
    $recursiveRef?: string;
    $recursiveAnchor?: boolean;
    $vocabulary?: {
        [k: string]: boolean;
    };
    $comment?: string;
    $defs?: {
        [k: string]: {
            [k: string]: unknown;
        };
    };
    [k: string]: unknown;
}
export interface ApplicatorVocabularyMetaSchema {
    additionalItems?: {
        [k: string]: unknown;
    };
    unevaluatedItems?: {
        [k: string]: unknown;
    };
    items?: {
        [k: string]: unknown;
    } | {
        [k: string]: unknown;
    }[];
    contains?: {
        [k: string]: unknown;
    };
    additionalProperties?: {
        [k: string]: unknown;
    };
    unevaluatedProperties?: {
        [k: string]: unknown;
    };
    properties?: {
        [k: string]: {
            [k: string]: unknown;
        };
    };
    patternProperties?: {
        [k: string]: {
            [k: string]: unknown;
        };
    };
    dependentSchemas?: {
        [k: string]: {
            [k: string]: unknown;
        };
    };
    propertyNames?: {
        [k: string]: unknown;
    };
    if?: {
        [k: string]: unknown;
    };
    then?: {
        [k: string]: unknown;
    };
    else?: {
        [k: string]: unknown;
    };
    allOf?: {
        [k: string]: unknown;
    }[];
    anyOf?: {
        [k: string]: unknown;
    }[];
    oneOf?: {
        [k: string]: unknown;
    }[];
    not?: {
        [k: string]: unknown;
    };
    [k: string]: unknown;
}
export interface ValidationVocabularyMetaSchema {
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: number;
    minimum?: number;
    exclusiveMinimum?: number;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    maxContains?: number;
    minContains?: number;
    maxProperties?: number;
    minProperties?: number;
    required?: string[];
    dependentRequired?: {
        [k: string]: string[];
    };
    const?: unknown;
    enum?: unknown[];
    type?: ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string") | ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[];
    [k: string]: unknown;
}
export interface MetaDataVocabularyMetaSchema {
    title?: string;
    description?: string;
    default?: unknown;
    deprecated?: boolean;
    readOnly?: boolean;
    writeOnly?: boolean;
    examples?: unknown[];
    [k: string]: unknown;
}
export interface FormatVocabularyMetaSchema {
    format?: string;
    [k: string]: unknown;
}
export interface ContentVocabularyMetaSchema {
    contentMediaType?: string;
    contentEncoding?: string;
    contentSchema?: {
        [k: string]: unknown;
    };
    [k: string]: unknown;
}
//# sourceMappingURL=rule.d.ts.map