@toolproof-npm/schema 0.1.34 → 0.1.36

package/dist/scripts/generateTypes.js

@@ -1,11 +1,13 @@
 import fs from 'fs';
 import path from 'path';
 import { compileFromFile } from 'json-schema-to-typescript';
-const projectRoot = process.cwd();
-const inputDir = path.join(projectRoot, 'src', 'schemas');
+import { getConfig } from './_lib/config.js';
+const config = getConfig();
+const projectRoot = config.getRoot();
+const inputDir = config.getOutputDir();
 // We emit under src/_lib/types and dist/_lib/types
-const srcLibTypesDir = path.join(projectRoot, 'src', '_lib', 'types');
-const srcLibOutputPath = path.join(srcLibTypesDir, 'types.d.ts');
+const srcLibTypesDir = config.getTypesSrcDir();
+const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
 // Build an index of all schema files by their basename
 // This supports location-independent $id values where folder segments were removed
 function buildSchemaIndex(root) {
@@ -59,7 +61,7 @@ function listAllSchemaFiles(root) {
             else if (entry.isFile() && entry.name.endsWith('.json')) {
                 if (entry.name === '.combined-schema.json')
                     continue; // ignore temp
-                // buildersuce path relative to root with posix separators
+                // produce path relative to root with posix separators
                 const rel = path.relative(root, full).split(path.sep).join('/');
                 files.push(rel);
             }
@@ -77,28 +79,28 @@ async function main() {
     const schemaIndex = buildSchemaIndex(inputDir);
     const idToCanonical = {};
     // Custom resolver to map our absolute schema IDs to local files, preventing HTTP fetches.
-    // Supports two patterns:
-    //  1. Legacy full-path IDs: https://schemas.toolproof.com/v0/genesis/Foo.json
-    //  2. Location-independent IDs: https://schemas.toolproof.com/v0/Foo.json
     const toolproofResolver = {
         order: 1,
         canRead: (file) => {
-            const url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
-            return (/^https?:\/\/schemas\.toolproof\.(documentation|com)\//i.test(url) ||
-                /^https?:\/\/toolproof\.com\/schemas\//i.test(url));
+            let url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
+            // Strip accidental wrapping quotes
+            if ((url.startsWith("'") && url.endsWith("'")) || (url.startsWith('"') && url.endsWith('"'))) {
+                url = url.slice(1, -1);
+            }
+            return config.isSchemaUrl(url);
         },
         read: (file) => {
-            const url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
+            let url = (typeof file.url === 'string' ? file.url : file.url?.href) || '';
+            // Strip accidental wrapping quotes
+            if ((url.startsWith("'") && url.endsWith("'")) || (url.startsWith('"') && url.endsWith('"'))) {
+                url = url.slice(1, -1);
+            }
             // Strip hash part (anchors) for path resolution
             const noHash = url.split('#')[0];
-            // Remove base domains
-            let rel = noHash
-                .replace(/^https?:\/\/schemas\.toolproof\.(documentation|com)\//i, '')
-                .replace(/^https?:\/\/toolproof\.com\/schemas\//i, '');
-            // Drop leading version segment (v0/, v1/, etc.) if present
-            rel = rel.replace(/^v\d+\//i, '');
+            // Extract schema name using config
+            const schemaName = config.extractSchemaName(noHash);
+            const fileName = schemaName.endsWith('.json') ? schemaName : `${schemaName}.json`;
             // Resolve by basename only (location-independent IDs)
-            const fileName = path.basename(rel);
             const indexed = schemaIndex.get(fileName);
             if (indexed) {
                 return fs.readFileSync(indexed, 'utf8');
@@ -109,7 +111,7 @@ async function main() {
     };
     // Files to include in the combined schema (auto-discovered, excludes documentation)
     const toCompile = listAllSchemaFiles(inputDir);
-    // Build definitions for a combined schema that references each file.
+    // Collect schema refs and defs; we'll compile files individually to avoid combined-schema traversal issues.
     const definitions = {};
     const includedNames = [];
     for (const fileName of toCompile) {
@@ -127,7 +129,13 @@ async function main() {
             const raw = fs.readFileSync(p, 'utf8');
             const parsed = JSON.parse(raw);
             if (parsed && typeof parsed.$id === 'string' && parsed.$id.trim()) {
-                refValue = parsed.$id.trim();
+                // Sanitize IDs that may have been emitted with surrounding quotes
+                // e.g. quotes around schema URL
+                let cleaned = parsed.$id.trim();
+                if ((cleaned.startsWith("'") && cleaned.endsWith("'")) || (cleaned.startsWith('"') && cleaned.endsWith('"'))) {
+                    cleaned = cleaned.slice(1, -1);
+                }
+                refValue = cleaned;
                 idToCanonical[refValue] = base + 'Json';
             }
             // Promote this file's $defs to top-level combined $defs so each gets its own exported type
@@ -156,40 +164,87 @@ async function main() {
         console.warn('No schema files found to compile. Nothing to do.');
         return;
     }
-    const combinedSchema = {
-        $id: 'combined-entry',
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        $defs: definitions,
-        anyOf: includedNames.map((n) => ({ $ref: `#/$defs/${n}` }))
-    };
-    console.log('combinedSchema:', JSON.stringify(combinedSchema, null, 2));
-    // Write combined schema to a temp file inside inputDir so relative $ref resolves.
-    const combinedPath = path.join(inputDir, '.combined-schema.json');
+    // Instead of building a combined schema (which can trip json-schema-to-typescript traversals),
+    // compile each discovered schema file individually and concatenate the outputs.
     try {
-        fs.writeFileSync(combinedPath, JSON.stringify(combinedSchema, null, 2), 'utf8');
-        // Compile the single combined schema; referenced schemas will be emitted once.
-        let ts = await compileFromFile(combinedPath, {
-            bannerComment: '',
-            // 
-            declareExternallyReferenced: true,
-            unreachableDefinitions: true,
-            // Forward ref parser options so absolute $id/$ref URLs resolve from local files
-            $refOptions: {
-                // Don’t go to the network; we provide a local resolver for our domain
-                resolve: {
-                    file: { order: 2 },
-                    http: false,
-                    https: false,
-                    toolproof: toolproofResolver
+        let ts = '';
+        for (const fileName of toCompile) {
+            const schemaPath = path.join(inputDir, fileName);
+            if (!fs.existsSync(schemaPath))
+                continue;
+            // Load and defensively normalize array-expected keywords to avoid generator crashes
+            let toCompilePath = schemaPath;
+            try {
+                const rawSchema = fs.readFileSync(schemaPath, 'utf8');
+                const parsedSchema = JSON.parse(rawSchema);
+                function normalizeArrays(node) {
+                    if (Array.isArray(node)) {
+                        for (let i = 0; i < node.length; i++)
+                            normalizeArrays(node[i]);
+                        return;
+                    }
+                    if (!node || typeof node !== 'object')
+                        return;
+                    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
+                    for (const k of arrayKeys) {
+                        if (k in node) {
+                            const v = node[k];
+                            if (!Array.isArray(v))
+                                node[k] = [v];
+                        }
+                    }
+                    for (const val of Object.values(node))
+                        normalizeArrays(val);
                 }
+                // Normalize expected arrays to prevent traversal crashes
+                normalizeArrays(parsedSchema);
+                const tmpPath = path.join(inputDir, `.normalized.${path.basename(fileName)}`);
+                fs.writeFileSync(tmpPath, JSON.stringify(parsedSchema, null, 2), 'utf8');
+                toCompilePath = tmpPath;
             }
-        });
+            catch (e) {
+                // If normalization fails, fall back to original path
+            }
+            const part = await compileFromFile(toCompilePath, {
+                bannerComment: '',
+                // 
+                declareExternallyReferenced: true,
+                unreachableDefinitions: true,
+                // Forward ref parser options so absolute $id/$ref URLs resolve from local files
+                $refOptions: {
+                    // Don’t go to the network; we provide a local resolver for our domain
+                    resolve: {
+                        file: { order: 2 },
+                        http: false,
+                        https: false,
+                        toolproof: toolproofResolver
+                    }
+                }
+            });
+            ts += '\n' + part + '\n';
+            // Cleanup temp normalized file
+            if (toCompilePath !== schemaPath) {
+                try {
+                    fs.unlinkSync(toCompilePath);
+                }
+                catch { }
+            }
+        }
         // Remove permissive index signatures that make interfaces open-ended.
         // Keep meaningful map-like signatures (e.g., `[k: string]: ResourceRoleValue`) intact.
         // Robust single-pass: delete the entire line (with optional trailing newline) where the signature appears.
         // This avoids introducing extra blank lines while handling CRLF/LF and varying indentation.
         ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
-        // Prune verbose type/interface names buildersuced from absolute $id URLs.
+        // Fix meta-schema types where json-schema-to-typescript incorrectly interprets
+        // schema definitions as literal values. ExtractionSchemaValue describes what
+        // an extraction schema looks like, not what the schema meta-properties should be.
+        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(\$defs\?:\s*\{[\s\S]*?};)/gm, '$1$defs?: {\n    [k: string]: unknown;\n  };');
+        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(properties\?:\s*\{[\s\S]*?};)/gm, '$1properties?: {\n    [k: string]: unknown;\n  };');
+        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(allOf\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];)/gm, '$1allOf?: Array<{[k: string]: unknown}>;');
+        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
+        // Similarly fix IdentityProp which has the same issue
+        ts = ts.replace(/^(export interface IdentityProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*contains:\s*\{const:\s*"identity"\};\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
+        // Prune verbose type/interface names produced from absolute $id URLs.
         // Deterministic pruning based on original $id -> baseName map
         // This avoids heuristic truncation that dropped prefixes like Resource / Workflow.
         function idToGeneratedIdentifier(id) {
@@ -217,8 +272,8 @@ async function main() {
         // Final cleanup: aggressively strip the domain prefix `HttpsSchemasToolproofCom` from ALL identifiers.
         // This is safe because those long names are only artifacts of json-schema-to-typescript; base names don't start with that sequence.
         ts = ts.replace(/\bHttpsSchemasToolproofCom(?=[A-Z])/g, '');
-        // Remove accidental duplicate union entries in CombinedEntry after shortening.
-        ts = ts.replace(/export type CombinedEntry =([\s\S]*?);/, (m, body) => {
+        // Remove accidental duplicate union entries in any exported union types after shortening.
+        ts = ts.replace(/export type ([A-Za-z0-9_]+) =([\s\S]*?);/g, (m, typeName, body) => {
             const lines = body.split(/\n/);
             const seen2 = new Set();
             const kept = [];
@@ -236,31 +291,25 @@ async function main() {
                     kept.push(line);
                 }
             }
-            return 'export type CombinedEntry =\n' + kept.join('\n') + ';';
+            return `export type ${typeName} =\n` + kept.join('\n') + ';';
         });
-        // If the compiler returned nothing (can happen if everything is externalized),
-        // try a direct compile of the primary catalog (Genesis.json) as a fallback.
+        // If nothing was emitted, compile Genesis.json as a final fallback.
         if (!ts || !ts.trim()) {
             const primary = path.join(inputDir, 'Genesis.json');
             if (fs.existsSync(primary)) {
-                try {
-                    ts = await compileFromFile(primary, {
-                        bannerComment: '',
-                        declareExternallyReferenced: true,
-                        unreachableDefinitions: true,
-                        $refOptions: {
-                            resolve: {
-                                file: { order: 2 },
-                                http: false,
-                                https: false,
-                                toolproof: toolproofResolver
-                            }
+                ts = await compileFromFile(primary, {
+                    bannerComment: '',
+                    declareExternallyReferenced: true,
+                    unreachableDefinitions: true,
+                    $refOptions: {
+                        resolve: {
+                            file: { order: 2 },
+                            http: false,
+                            https: false,
+                            toolproof: toolproofResolver
                         }
-                    });
-                }
-                catch (e) {
-                    // ignore and fall through to stub
-                }
+                    }
+                });
             }
         }
         // Still nothing? ensure we emit a module so downstream imports don't fail.
@@ -294,7 +343,7 @@ async function main() {
         function loadIdTemplates() {
             const map = {};
             try {
-                const genesisPath = path.join(inputDir, 'Genesis.json');
+                const genesisPath = path.join(inputDir, config.getSourceFile());
                 if (fs.existsSync(genesisPath)) {
                     const raw = fs.readFileSync(genesisPath, 'utf8');
                     const parsed = JSON.parse(raw);
@@ -333,7 +382,7 @@ async function main() {
         // Replace index-signature interfaces with Record<IdType, ValueType> so object literal keys are checked.
         ts = ts.replace(/export interface RoleMap\s*{[^}]*}/g, 'export type RoleMap = Record<ResourceRoleId, ResourceRoleValue>;');
         ts = ts.replace(/export interface RoleBindingMap\s*{[^}]*}/g, 'export type RoleBindingMap = Record<ResourceRoleId, ResourceId>;');
-        ts = ts.replace(/export interface ResourceMap\s*\{[^}]*\{[^}]*\}[^}]*\}/gs, 'export type ResourceMap = Record<ExecutionId, Record<ResourceRoleId, ResourcePotentialInput | ResourcePotentialOutput | ResourceData>>;');
+        ts = ts.replace(/export interface StrategyState\s*\{[^}]*\{[^}]*\}[^}]*\}/gs, 'export type StrategyState = Record<ExecutionId, Record<ResourceRoleId, ResourcePotentialInput | ResourcePotentialOutput | Resource>>;');
         parts.push(ts);
         let output = parts.join('\n');
         // Final guard: strip any lingering `[k: string]: unknown;` that might have been
@@ -361,8 +410,8 @@ async function main() {
         }
         // Also write a copy into dist so consumers get the generated declarations
         // Write only to dist/_lib/types to keep the same path structure under dist
-        const distLibTypesDir = path.join(projectRoot, 'dist', '_lib', 'types');
-        const distLibOutputPath = path.join(distLibTypesDir, 'types.d.ts');
+        const distLibTypesDir = config.getTypesDistDir();
+        const distLibOutputPath = config.getTypesDistPath('types.d.ts');
         try {
             fs.mkdirSync(distLibTypesDir, { recursive: true });
             fs.writeFileSync(distLibOutputPath, output, 'utf8');
@@ -376,7 +425,7 @@ async function main() {
         // Some consumers and TS NodeNext resolution expect a concrete .js next to .d.ts
         // The file is intentionally empty as all exports are types-only.
         try {
-            const srcLibTypesJsPath = path.join(srcLibTypesDir, 'types.js');
+            const srcLibTypesJsPath = config.getTypesSrcPath('types.js');
             if (!fs.existsSync(srcLibTypesJsPath)) {
                 fs.writeFileSync(srcLibTypesJsPath, 'export {}\n', 'utf8');
                 console.log('Wrote', srcLibTypesJsPath);
@@ -386,7 +435,7 @@ async function main() {
             console.warn('Failed to write types.js to src/_lib:', e);
         }
         try {
-            const distLibTypesJsPath = path.join(distLibTypesDir, 'types.js');
+            const distLibTypesJsPath = config.getTypesDistPath('types.js');
             fs.writeFileSync(distLibTypesJsPath, 'export {}\n', 'utf8');
             console.log('Wrote', distLibTypesJsPath);
         }
@@ -395,14 +444,7 @@ async function main() {
         }
     }
     finally {
-        // Best-effort cleanup of the temporary combined schema
-        try {
-            if (fs.existsSync(combinedPath))
-                fs.unlinkSync(combinedPath);
-        }
-        catch (e) {
-            // ignore cleanup errors
-        }
+        // No temp combined schema used.
     }
 }
 main().catch((err) => {

package/dist/scripts/rewriteAnchors.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/rewriteAnchors.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import { getConfig } from './_lib/config.js';
+/**
+ * Rewrite anchor-style references to JSON Pointer references
+ * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict JSON Schema validators
+ *
+ * This function works on a schema object that has $defs at its top level.
+ * For Genesis, each $defs entry is a Type envelope with an extractionSchema that may have $anchor.
+ */
+function rewriteAnchorsToPointers(root) {
+    if (!root || typeof root !== "object")
+        return;
+    // Build a map of anchors to their definition names
+    const defs = root.$defs && typeof root.$defs === "object" ? root.$defs : {};
+    const anchorToDef = {};
+    // For Genesis structure: each def is a Type envelope with extractionSchema.$anchor
+    for (const [defName, defValue] of Object.entries(defs)) {
+        if (!defValue || typeof defValue !== "object")
+            continue;
+        // Check if this is a Type envelope (has extractionSchema property)
+        const extractionSchema = defValue.extractionSchema;
+        if (extractionSchema && typeof extractionSchema === "object") {
+            // Look for $anchor inside the extractionSchema
+            const anchor = extractionSchema.$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+        else {
+            // Fallback: check for $anchor at the def level (non-envelope case)
+            const anchor = defValue.$anchor;
+            if (typeof anchor === "string" && !anchorToDef[anchor]) {
+                anchorToDef[anchor] = defName;
+            }
+        }
+    }
+    // Walk the entire tree and rewrite anchor refs to pointer refs
+    function walk(node) {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item);
+            return;
+        }
+        if (!node || typeof node !== "object")
+            return;
+        // Rewrite $ref if it's an anchor-style reference
+        if (typeof node.$ref === "string") {
+            const ref = node.$ref;
+            // Match anchor refs: starts with # but not #/ (JSON Pointer syntax)
+            if (ref.startsWith("#") && !ref.startsWith("#/")) {
+                const anchor = ref.slice(1);
+                const defName = anchorToDef[anchor];
+                if (defName) {
+                    node.$ref = `#/$defs/${defName}`;
+                }
+            }
+        }
+        // Recursively walk all properties
+        for (const val of Object.values(node)) {
+            walk(val);
+        }
+    }
+    walk(root);
+}
+async function main() {
+    const config = getConfig();
+    const genesisSourcePath = config.getSourcePath();
+    // Create a temporary normalized version
+    const normalizedPath = genesisSourcePath.replace('.json', '.normalized.json');
+    if (!fs.existsSync(genesisSourcePath)) {
+        console.error(`Genesis source file not found at ${genesisSourcePath}`);
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(genesisSourcePath, 'utf-8');
+    const genesis = JSON.parse(raw);
+    // Validate structure
+    if (!genesis.extractionSchema || !genesis.extractionSchema.$defs) {
+        console.error('Genesis.json must have extractionSchema.$defs');
+        process.exit(1);
+    }
+    // Rewrite anchors in the extractionSchema (where $defs is at the top level)
+    rewriteAnchorsToPointers(genesis.extractionSchema);
+    // Write normalized version
+    fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');
+    console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",
@@ -44,10 +44,13 @@
   "scripts": {
     "build": "tsc -b",
     "build:scripts": "tsc -p tsconfig.scripts.json",
+    "rewriteAnchors": "node ./dist/scripts/rewriteAnchors.js",
     "extractSchemas": "node ./dist/scripts/extractSchemas.js",
     "extractSubschema": "node ./dist/scripts/extractSubschemaWithDefs.js",
     "generateTypes": "node ./dist/scripts/generateTypes.js",
-    "generateResourceData": "node ./dist/scripts/generateResourceData.js",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run extractSchemas -- --in src/genesis/Genesis.json --out src/schemas/Genesis.json --id 'https://schemas.toolproof.com/v0/Genesis.json' && pnpm run extractSubschema -- --name Job && pnpm run generateTypes && pnpm run generateResourceData -- --name Job && pnpm run build"
+    "generateResourceTypeType": "node ./dist/scripts/generateResourceTypeType.js",
+    "generateResourceEnvelopes": "node ./dist/scripts/generateResourceEnvelopes.js",
+    "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run rewriteAnchors && pnpm run generateResourceEnvelopes && pnpm run extractSchemas && pnpm run extractSubschema -- --name Job && pnpm run extractSubschema -- --name ResourceFormat && pnpm run extractSubschema -- --name ResourceType && pnpm run extractSubschema -- --name StatelessStrategy && pnpm run extractSubschema -- --name StatefulStrategy && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateResourceTypeType -- --name Job && pnpm run generateResourceTypeType -- --name ResourceFormat && pnpm run generateResourceTypeType -- --name ResourceType && pnpm run generateResourceTypeType -- --name StatelessStrategy && pnpm run build"
   }
 }

package/dist/_lib/types/ResourceData_Job.d.ts

@@ -1,97 +0,0 @@
-// Auto-generated strict composite type. Do not edit.
-export type ResourceData_Job = ResourceMetaBase & {
-  extractedData: Job;
-};
-export type ResourceMetaBase = ResourceBase &
-  ResourceKind & {
-    kind: "materialized";
-  } & Path &
-  Timestamp;
-export type ResourceBase = Identifiable & {
-  id: string;
-} & {
-  resourceTypeId: string;
-} & CreationContext;
-export type Job = Documented &
-  RolesOuter &
-  Uri & {
-    identity: string;
-  };
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "Documented".
- */
-export type Documented = Name & Description;
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "ResourceRoleValue".
- */
-export type ResourceRoleValue = {
-  /**
-   * This interface was referenced by `undefined`'s JSON-Schema
-   * via the `definition` "ResourceTypeId".
-   */
-  resourceTypeId: string;
-} & Documented;
-
-export interface Identifiable {
-}
-export interface CreationContext {
-  creationContext: ResourceSocket;
-}
-export interface ResourceSocket {
-  executionId: string;
-  resourceRoleId: string;
-}
-export interface ResourceKind {
-  kind: "potential-input" | "potential-output" | "materialized";
-}
-export interface Path {
-  path: string;
-}
-export interface Timestamp {
-  timestamp: string;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "Name".
- */
-export interface Name {
-  name: string;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "Description".
- */
-export interface Description {
-  description: string;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "RolesOuter".
- */
-export interface RolesOuter {
-  roles: RolesInner;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "RolesInner".
- */
-export interface RolesInner {
-  inputMap: RoleMap;
-  outputMap: RoleMap;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "RoleMap".
- */
-export interface RoleMap {
-  [k: string]: ResourceRoleValue;
-}
-/**
- * This interface was referenced by `undefined`'s JSON-Schema
- * via the `definition` "Uri".
- */
-export interface Uri {
-  uri: string;
-}