@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/schemaPattern.d.ts

@@ -0,0 +1,1062 @@
+/** Evidenced XSD regex subset for schema operands and #184's enforcement plan. */
+import type { SchemaPatternContext } from "./schemaValueContext.js";
+export type PatternAtom = Readonly<{
+    kind: "character";
+    expression: string;
+} | {
+    kind: "sequence";
+    children: readonly number[];
+} | {
+    kind: "choice";
+    children: readonly number[];
+} | {
+    kind: "repeat";
+    child: number;
+    min: string;
+    max: string | "unbounded";
+}>;
+export type SchemaPattern = Readonly<{
+    language: "xsd10-whole-string";
+    atoms: readonly PatternAtom[];
+    root: number;
+    unicode: "code-points";
+    runtimeOwner: "#184";
+}>;
+export declare function schemaPatterns<Owner>(c: SchemaPatternContext<Owner>): {
+    compile: (lexical: Readonly<{
+        value: string;
+        context: Readonly<{
+            namespaces: Readonly<Record<string, string>>;
+            source: Readonly<{
+                uri: string;
+                digest: string;
+                path: string;
+                start: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+                end: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+            }>;
+        }>;
+    }>, owner: Owner) => Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>;
+    acceptsOperand: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, value: string, owner: Owner) => boolean;
+    literalLanguage: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner) => {
+        kind: "finite-literal";
+        words: Generator<string>;
+    } | {
+        kind: "outside-fragment";
+    };
+    positiveWords: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, hints: string) => Generator<string>;
+    language: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, authority?: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    }) => Readonly<{
+        kind: "private-regular-language";
+    }>;
+    regular: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    };
+};
+/** Closed assessment-schema consumer; this does not widen the application profile. */
+export declare function fixedS4SPatterns<Owner>(c: SchemaPatternContext<Owner>): {
+    compile: (lexical: Readonly<{
+        value: string;
+        context: Readonly<{
+            namespaces: Readonly<Record<string, string>>;
+            source: Readonly<{
+                uri: string;
+                digest: string;
+                path: string;
+                start: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+                end: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+            }>;
+        }>;
+    }>, owner: Owner) => Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>;
+    acceptsOperand: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, value: string, owner: Owner) => boolean;
+    literalLanguage: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner) => {
+        kind: "finite-literal";
+        words: Generator<string>;
+    } | {
+        kind: "outside-fragment";
+    };
+    positiveWords: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, hints: string) => Generator<string>;
+    language: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, authority?: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    }) => Readonly<{
+        kind: "private-regular-language";
+    }>;
+    regular: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    };
+};
+/** Private original builtin facet-component consumer; caller patterns keep their profile. */
+export declare function intrinsicBuiltinPatterns<Owner>(c: SchemaPatternContext<Owner>): {
+    compile: (lexical: Readonly<{
+        value: string;
+        context: Readonly<{
+            namespaces: Readonly<Record<string, string>>;
+            source: Readonly<{
+                uri: string;
+                digest: string;
+                path: string;
+                start: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+                end: Readonly<{
+                    offset: number;
+                    line: number;
+                    column: number;
+                }>;
+            }>;
+        }>;
+    }>, owner: Owner) => Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>;
+    acceptsOperand: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, value: string, owner: Owner) => boolean;
+    literalLanguage: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner) => {
+        kind: "finite-literal";
+        words: Generator<string>;
+    } | {
+        kind: "outside-fragment";
+    };
+    positiveWords: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, hints: string) => Generator<string>;
+    language: (pattern: Readonly<{
+        language: "xsd10-whole-string";
+        atoms: readonly PatternAtom[];
+        root: number;
+        unicode: "code-points";
+        runtimeOwner: "#184";
+    }>, owner: Owner, authority?: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    }) => Readonly<{
+        kind: "private-regular-language";
+    }>;
+    regular: {
+        fromPattern: (atoms: readonly PatternAtom[], root: number, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        intersect: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        union: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        negate: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        witness: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => string | undefined;
+        finiteWords: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => {
+            kind: "infinite";
+        } | {
+            kind: "finite";
+            words: Generator<string>;
+        };
+        automaton: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>;
+        fromAutomaton: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        fromNfa: (program: Readonly<{
+            edges: readonly (readonly Readonly<{
+                to: number;
+                ranges?: readonly (readonly [number, number])[];
+            }>[])[];
+            start: number;
+            end: number;
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        substitutionGraph: (count: number, start: number, end: number, labels: readonly {
+            from: number;
+            to: number;
+            language: Readonly<{
+                kind: "private-regular-language";
+            }>;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        jsonStringImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        paths: (program: Readonly<{
+            states: readonly Readonly<{
+                accepting: boolean;
+                transitions: readonly Readonly<{
+                    to: number;
+                    lo: number;
+                    hi: number;
+                }>[];
+            }>[];
+            start: number;
+        }>, starts: readonly number[], ends: ReadonlySet<number>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        quotient: (source: Readonly<{
+            kind: "private-regular-language";
+        }>, prefix: Readonly<{
+            kind: "private-regular-language";
+        }>, suffix: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        reverse: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        concatenate: (languages: readonly Readonly<{
+            kind: "private-regular-language";
+        }>[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        repeat: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, min: number, max: number | "unbounded", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespacePreimage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        whitespaceImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, mode: "preserve" | "replace" | "collapse", owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        characterImage: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, changes: readonly {
+            lo: number;
+            hi: number;
+            shift?: number;
+            remove?: boolean;
+        }[], owner: Owner) => Readonly<{
+            kind: "private-regular-language";
+        }>;
+        words: (language: Readonly<{
+            kind: "private-regular-language";
+        }>, owner: Owner) => Generator<string>;
+    };
+};
+//# sourceMappingURL=schemaPattern.d.ts.map