export { SpruceSchemas } from '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schemas.types'; import { default as SchemaEntity } from '@sprucelabs/schema'; import * as SpruceSchema from '@sprucelabs/schema'; import { BaseWidget } from './../../widgets/types/widgets.types'; import AbstractSpruceError from '@sprucelabs/error'; declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schemas.types' { namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface GeneratedDir { 'name': string; 'path': string; 'description'?: string | undefined | null; 'action': ("skipped" | "generated" | "updated" | "deleted"); } interface GeneratedDirSchema extends SpruceSchema.Schema { id: 'generatedDir'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: ''; fields: { /** . */ 'name': { type: 'text'; isRequired: true; options: undefined; }; /** . */ 'path': { type: 'text'; isRequired: true; options: undefined; }; /** . */ 'description': { type: 'text'; options: undefined; }; /** . */ 'action': { type: 'select'; isRequired: true; options: { choices: [{ "label": "Skipped"; "value": "skipped"; }, { "label": "Generated"; "value": "generated"; }, { "label": "Updated"; "value": "updated"; }, { "label": "Deleted"; "value": "deleted"; }]; }; }; }; } interface GeneratedDirEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface WatcherDidDetectChangesEmitPayload { 'changes': ({ id: 'generatedFile'; values: SpruceSchemas.SpruceCli.v2020_07_22.GeneratedFile; } | { id: 'generatedDir'; values: SpruceSchemas.SpruceCli.v2020_07_22.GeneratedDir; })[]; } interface WatcherDidDetectChangesEmitPayloadSchema extends SpruceSchema.Schema { id: 'watcherDidDetectChangesEmitPayload'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Watcher did detect changes emit payload'; fields: { /** . */ 'changes': { type: 'schema'; isRequired: true; isArray: true; options: { schemas: (SpruceSchemas.SpruceCli.v2020_07_22.GeneratedFileSchema | SpruceSchemas.SpruceCli.v2020_07_22.GeneratedDirSchema)[]; }; }; }; } interface WatcherDidDetectChangesEmitPayloadEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Upgrade. Everything. Heads up, this can take a few minutes. ⏱ */ interface UpgradeSkillOptions { /** Upgrade mode. */ 'upgradeMode'?: ("askForChanged" | "forceEverything" | "forceRequiredSkipRest") | undefined | null; } interface UpgradeSkillOptionsSchema extends SpruceSchema.Schema { id: 'upgradeSkillOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Upgrade skill action'; description: 'Upgrade. Everything. Heads up, this can take a few minutes. ⏱'; fields: { /** Upgrade mode. */ 'upgradeMode': { label: 'Upgrade mode'; type: 'select'; defaultValue: "askForChanged"; options: { choices: [{ "value": "askForChanged"; "label": "Ask for changed files"; }, { "value": "forceEverything"; "label": "Force everything"; }, { "value": "forceRequiredSkipRest"; "label": "Force required (skipping all non-essential)"; }]; }; }; }; } interface UpgradeSkillOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Test your might! 💪 */ interface TestOptions { /** Report while running. Should I output the test results while they are running? */ 'shouldReportWhileRunning'?: boolean | undefined | null; /** Pattern. I'll filter all tests that match this pattern */ 'pattern'?: string | undefined | null; /** Inspect. Pass --inspect related args to test process. */ 'inspect'?: number | undefined | null; /** Should wait for manual start?. */ 'shouldHoldAtStart'?: boolean | undefined | null; /** Wait until tests are finished. For testing. Returns immediately after executing test so the running process can be managed programatically. */ 'shouldReturnImmediately'?: boolean | undefined | null; /** Watch. */ 'watchMode'?: ("off" | "standard" | "smart") | undefined | null; } interface TestOptionsSchema extends SpruceSchema.Schema { id: 'testOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Test skill'; description: 'Test your might! 💪'; fields: { /** Report while running. Should I output the test results while they are running? */ 'shouldReportWhileRunning': { label: 'Report while running'; type: 'boolean'; hint: 'Should I output the test results while they are running?'; defaultValue: true; options: undefined; }; /** Pattern. I'll filter all tests that match this pattern */ 'pattern': { label: 'Pattern'; type: 'text'; hint: 'I\'ll filter all tests that match this pattern'; options: undefined; }; /** Inspect. Pass --inspect related args to test process. */ 'inspect': { label: 'Inspect'; type: 'number'; hint: 'Pass --inspect related args to test process.'; options: undefined; }; /** Should wait for manual start?. */ 'shouldHoldAtStart': { label: 'Should wait for manual start?'; type: 'boolean'; defaultValue: false; options: undefined; }; /** Wait until tests are finished. For testing. Returns immediately after executing test so the running process can be managed programatically. */ 'shouldReturnImmediately': { label: 'Wait until tests are finished'; type: 'boolean'; isPrivate: true; hint: 'For testing. Returns immediately after executing test so the running process can be managed programatically.'; defaultValue: false; options: undefined; }; /** Watch. */ 'watchMode': { label: 'Watch'; type: 'select'; options: { choices: [{ "value": "off"; "label": "Off"; }, { "value": "standard"; "label": "Standard"; }, { "value": "smart"; "label": "Smart"; }]; }; }; }; } interface TestOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Options for schema.sync. */ interface SyncSchemasOptions { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir'?: string | undefined | null; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir'?: string | undefined | null; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes'?: boolean | undefined | null; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile'?: string | undefined | null; /** . Where I should look for your schema builders? */ 'schemaLookupDir'?: string | undefined | null; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote'?: string | undefined | null; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies'?: boolean | undefined | null; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning'?: boolean | undefined | null; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace'?: string | undefined | null; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas'?: boolean | undefined | null; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas'?: boolean | undefined | null; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas'?: boolean | undefined | null; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes'?: boolean | undefined | null; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas'?: boolean | undefined | null; /** Delete directory if no schemas. Should I delete the schema directory if no schemas are found? */ 'deleteDestinationDirIfNoSchemas'?: boolean | undefined | null; /** Delete orphaned schemas. Should I delete schemas where the builders are missing? */ 'deleteOrphanedSchemas'?: boolean | undefined | null; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile'?: boolean | undefined | null; /** message. */ 'syncingMessage'?: string | undefined | null; } interface SyncSchemasOptionsSchema extends SpruceSchema.Schema { id: 'syncSchemasOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Sync schemas action'; description: 'Options for schema.sync.'; fields: { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir': { label: 'Field types directory'; type: 'text'; isPrivate: true; hint: 'Where field types and interfaces will be generated.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir': { label: 'Addons lookup directory'; type: 'text'; hint: 'Where I\'ll look for new schema fields to be registered.'; defaultValue: "src/addons"; options: undefined; }; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes': { label: 'Generate field types'; type: 'boolean'; isPrivate: true; hint: 'Should I generate field types too?'; defaultValue: true; options: undefined; }; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile': { label: 'Schema types destination directory'; type: 'text'; hint: 'Where I will generate schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** . Where I should look for your schema builders? */ 'schemaLookupDir': { type: 'text'; hint: 'Where I should look for your schema builders?'; defaultValue: "src/schemas"; options: undefined; }; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote': { label: 'Module import'; type: 'text'; hint: 'When other skills use your schemas, will they import them from a module?'; options: undefined; }; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies': { label: 'Auto install missing dependencies'; type: 'boolean'; options: undefined; }; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning': { label: 'Enable versioning'; type: 'boolean'; isPrivate: true; hint: 'Should we use versioning?'; defaultValue: true; options: undefined; }; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace': { label: 'Global namespace'; type: 'text'; isPrivate: true; hint: 'The name you\'ll use when accessing these schemas, e.g. SpruceSchemas'; defaultValue: "SpruceSchemas"; options: undefined; }; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas': { label: 'Fetch remote schemas'; type: 'boolean'; isPrivate: true; hint: 'I will pull in schemas from other features.'; defaultValue: true; options: undefined; }; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas': { label: 'Fetch local schemas'; type: 'boolean'; isPrivate: true; hint: 'I will look in schemaLookupDir to load local schemas.'; defaultValue: true; options: undefined; }; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas': { label: 'Fetch core schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I pull in core schemas too?'; defaultValue: true; options: undefined; }; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes': { label: 'Generate core schemas'; type: 'boolean'; isPrivate: true; hint: 'Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile.'; options: undefined; }; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas': { label: 'Register built schemas'; type: 'boolean'; isPrivate: true; hint: 'Should the schemas use the SchemaRegistry for tracking?'; defaultValue: true; options: undefined; }; /** Delete directory if no schemas. Should I delete the schema directory if no schemas are found? */ 'deleteDestinationDirIfNoSchemas': { label: 'Delete directory if no schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I delete the schema directory if no schemas are found?'; defaultValue: false; options: undefined; }; /** Delete orphaned schemas. Should I delete schemas where the builders are missing? */ 'deleteOrphanedSchemas': { label: 'Delete orphaned schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I delete schemas where the builders are missing?'; defaultValue: true; options: undefined; }; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile': { label: 'Generate standalone types file'; type: 'boolean'; isPrivate: true; hint: 'By default, I\'ll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file.'; defaultValue: false; options: undefined; }; /** message. */ 'syncingMessage': { label: ' message'; type: 'text'; isPrivate: true; defaultValue: "Syncing schemas..."; options: undefined; }; }; } interface SyncSchemasOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Sync schema fields so you can use schemas! */ interface SyncSchemaFieldsOptions { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir'?: string | undefined | null; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir'?: string | undefined | null; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes'?: boolean | undefined | null; } interface SyncSchemaFieldsOptionsSchema extends SpruceSchema.Schema { id: 'syncSchemaFieldsOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'syncSchemaFieldsOptions'; description: 'Sync schema fields so you can use schemas!'; fields: { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir': { label: 'Field types directory'; type: 'text'; isPrivate: true; hint: 'Where field types and interfaces will be generated.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir': { label: 'Addons lookup directory'; type: 'text'; hint: 'Where I\'ll look for new schema fields to be registered.'; defaultValue: "src/addons"; options: undefined; }; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes': { label: 'Generate field types'; type: 'boolean'; isPrivate: true; hint: 'Should I generate field types too?'; defaultValue: true; options: undefined; }; }; } interface SyncSchemaFieldsOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Pull down event contracts from Mercury to make them available in your skill. */ interface SyncEventOptions { /** Contract destination. Where I will generate event contracts. */ 'contractDestinationDir'?: string | undefined | null; /** Schema types lookup directory. Where I will lookup schema types and interfaces. */ 'schemaTypesLookupDir'?: string | undefined | null; /** Sync only core events. For use in @sprucelabs/mercury-types */ 'shouldSyncOnlyCoreEvents'?: boolean | undefined | null; /** Event signature types file. */ 'skillEventContractTypesFile'?: string | undefined | null; /** Event builder file. */ 'eventBuilderFile'?: string | undefined | null; } interface SyncEventOptionsSchema extends SpruceSchema.Schema { id: 'syncEventOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'sync event action'; description: 'Pull down event contracts from Mercury to make them available in your skill.'; fields: { /** Contract destination. Where I will generate event contracts. */ 'contractDestinationDir': { label: 'Contract destination'; type: 'text'; hint: 'Where I will generate event contracts.'; defaultValue: "#spruce/events"; options: undefined; }; /** Schema types lookup directory. Where I will lookup schema types and interfaces. */ 'schemaTypesLookupDir': { label: 'Schema types lookup directory'; type: 'text'; hint: 'Where I will lookup schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Sync only core events. For use in @sprucelabs/mercury-types */ 'shouldSyncOnlyCoreEvents': { label: 'Sync only core events'; type: 'boolean'; hint: 'For use in @sprucelabs/mercury-types'; options: undefined; }; /** Event signature types file. */ 'skillEventContractTypesFile': { label: 'Event signature types file'; type: 'text'; defaultValue: "@sprucelabs/mercury-types/build/types/mercury.types"; options: undefined; }; /** Event builder file. */ 'eventBuilderFile': { label: 'Event builder file'; type: 'text'; defaultValue: "@sprucelabs/mercury-types"; options: undefined; }; }; } interface SyncEventOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Keep your errors types in sync with your builders */ interface SyncErrorOptions { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir'?: string | undefined | null; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir'?: string | undefined | null; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes'?: boolean | undefined | null; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile'?: string | undefined | null; /** . Where I should look for your schema builders? */ 'schemaLookupDir'?: string | undefined | null; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote'?: string | undefined | null; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies'?: boolean | undefined | null; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning'?: boolean | undefined | null; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace'?: string | undefined | null; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas'?: boolean | undefined | null; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas'?: boolean | undefined | null; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas'?: boolean | undefined | null; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes'?: boolean | undefined | null; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas'?: boolean | undefined | null; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile'?: boolean | undefined | null; /** message. */ 'syncingMessage'?: string | undefined | null; /** Error class destination. Where I'll save your new Error class file? */ 'errorClassDestinationDir': string; /** . Where I should look for your error builders? */ 'errorLookupDir'?: string | undefined | null; /** Types destination dir. This is where error options and type information will be written */ 'errorTypesDestinationDir'?: string | undefined | null; } interface SyncErrorOptionsSchema extends SpruceSchema.Schema { id: 'syncErrorOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Sync error action'; description: 'Keep your errors types in sync with your builders'; fields: { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir': { label: 'Field types directory'; type: 'text'; isPrivate: true; hint: 'Where field types and interfaces will be generated.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir': { label: 'Addons lookup directory'; type: 'text'; hint: 'Where I\'ll look for new schema fields to be registered.'; defaultValue: "src/addons"; options: undefined; }; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes': { label: 'Generate field types'; type: 'boolean'; isPrivate: true; hint: 'Should I generate field types too?'; defaultValue: true; options: undefined; }; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile': { label: 'Schema types destination directory'; type: 'text'; hint: 'Where I will generate schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** . Where I should look for your schema builders? */ 'schemaLookupDir': { type: 'text'; hint: 'Where I should look for your schema builders?'; defaultValue: "src/schemas"; options: undefined; }; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote': { label: 'Module import'; type: 'text'; hint: 'When other skills use your schemas, will they import them from a module?'; options: undefined; }; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies': { label: 'Auto install missing dependencies'; type: 'boolean'; options: undefined; }; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning': { label: 'Enable versioning'; type: 'boolean'; isPrivate: true; hint: 'Should we use versioning?'; defaultValue: true; options: undefined; }; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace': { label: 'Global namespace'; type: 'text'; isPrivate: true; hint: 'The name you\'ll use when accessing these schemas, e.g. SpruceSchemas'; defaultValue: "SpruceSchemas"; options: undefined; }; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas': { label: 'Fetch remote schemas'; type: 'boolean'; isPrivate: true; hint: 'I will pull in schemas from other features.'; defaultValue: true; options: undefined; }; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas': { label: 'Fetch local schemas'; type: 'boolean'; isPrivate: true; hint: 'I will look in schemaLookupDir to load local schemas.'; defaultValue: true; options: undefined; }; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas': { label: 'Fetch core schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I pull in core schemas too?'; defaultValue: true; options: undefined; }; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes': { label: 'Generate core schemas'; type: 'boolean'; isPrivate: true; hint: 'Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile.'; options: undefined; }; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas': { label: 'Register built schemas'; type: 'boolean'; isPrivate: true; hint: 'Should the schemas use the SchemaRegistry for tracking?'; defaultValue: true; options: undefined; }; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile': { label: 'Generate standalone types file'; type: 'boolean'; isPrivate: true; hint: 'By default, I\'ll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file.'; defaultValue: false; options: undefined; }; /** message. */ 'syncingMessage': { label: ' message'; type: 'text'; isPrivate: true; defaultValue: "Syncing schemas..."; options: undefined; }; /** Error class destination. Where I'll save your new Error class file? */ 'errorClassDestinationDir': { label: 'Error class destination'; type: 'text'; isPrivate: true; isRequired: true; hint: 'Where I\'ll save your new Error class file?'; defaultValue: "src/errors"; options: undefined; }; /** . Where I should look for your error builders? */ 'errorLookupDir': { type: 'text'; hint: 'Where I should look for your error builders?'; defaultValue: "src/errors"; options: undefined; }; /** Types destination dir. This is where error options and type information will be written */ 'errorTypesDestinationDir': { label: 'Types destination dir'; type: 'text'; hint: 'This is where error options and type information will be written'; defaultValue: "#spruce/errors"; options: undefined; }; }; } interface SyncErrorOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface SkillFeature { 'destination'?: string | undefined | null; /** What's the name of your skill?. This marketing focused, like "8-bit Stories" or "Adventures". */ 'name': string; /** How would you describe your skill?. */ 'description': string; } interface SkillFeatureSchema extends SpruceSchema.Schema { id: 'skillFeature'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Skill feature options'; fields: { /** . */ 'destination': { type: 'text'; defaultValue: "."; options: undefined; }; /** What's the name of your skill?. This marketing focused, like "8-bit Stories" or "Adventures". */ 'name': { label: 'What\'s the name of your skill?'; type: 'text'; isRequired: true; hint: 'This marketing focused, like "8-bit Stories" or "Adventures".'; options: undefined; }; /** How would you describe your skill?. */ 'description': { label: 'How would you describe your skill?'; type: 'text'; isRequired: true; options: undefined; }; }; } interface SkillFeatureEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Install vscode extensions, launch configs, and settings the Spruce team uses in-house! */ interface SetupVscodeOptions { /** Install everything. */ 'all'?: boolean | undefined | null; } interface SetupVscodeOptionsSchema extends SpruceSchema.Schema { id: 'setupVscodeOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Setup vscode action'; description: 'Install vscode extensions, launch configs, and settings the Spruce team uses in-house!'; fields: { /** Install everything. */ 'all': { label: 'Install everything'; type: 'boolean'; options: undefined; }; }; } interface SetupVscodeOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Use this with in your CI/CD environment to get your skill ready to run tests. */ interface SetupTestsOptions { /** Demo phone number. */ 'demoNumber': string; /** Namespace. */ 'skillSlug': string; } interface SetupTestsOptionsSchema extends SpruceSchema.Schema { id: 'setupTestsOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Setup tests options'; description: 'Use this with in your CI/CD environment to get your skill ready to run tests.'; fields: { /** Demo phone number. */ 'demoNumber': { label: 'Demo phone number'; type: 'phone'; isRequired: true; options: undefined; }; /** Namespace. */ 'skillSlug': { label: 'Namespace'; type: 'text'; isRequired: true; options: undefined; }; }; } interface SetupTestsOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface RegisterDashboardWidgetsEmitPayloadSchema { 'widgets'?: (BaseWidget) | undefined | null; } interface RegisterDashboardWidgetsEmitPayloadSchemaSchema extends SpruceSchema.Schema { id: 'registerDashboardWidgetsEmitPayloadSchema'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'register dashboard widgets emit payload schema'; fields: { /** . */ 'widgets': { type: 'raw'; options: { valueType: `BaseWidget`; }; }; }; } interface RegisterDashboardWidgetsEmitPayloadSchemaEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** A stripped down cli user with token details for login */ interface PersonWithToken { /** Id. */ 'id': string; /** Casual name. The name you can use when talking to this person. */ 'casualName': string; 'token': string; /** Logged in. */ 'isLoggedIn'?: boolean | undefined | null; } interface PersonWithTokenSchema extends SpruceSchema.Schema { id: 'personWithToken'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: ''; description: 'A stripped down cli user with token details for login'; fields: { /** Id. */ 'id': { label: 'Id'; type: 'id'; isRequired: true; options: undefined; }; /** Casual name. The name you can use when talking to this person. */ 'casualName': { label: 'Casual name'; type: 'text'; isRequired: true; hint: 'The name you can use when talking to this person.'; options: undefined; }; /** . */ 'token': { type: 'text'; isRequired: true; options: undefined; }; /** Logged in. */ 'isLoggedIn': { label: 'Logged in'; type: 'boolean'; options: undefined; }; }; } interface PersonWithTokenEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Track onboarding progress and tutorials & quizzes completed. */ interface Onboarding { /** mode. */ 'mode': ("short" | "immersive" | "off"); /** Stage. */ 'stage'?: ("create.skill" | "test") | undefined | null; } interface OnboardingSchema extends SpruceSchema.Schema { id: 'onboarding'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Onboarding'; description: 'Track onboarding progress and tutorials & quizzes completed.'; fields: { /** mode. */ 'mode': { label: 'mode'; type: 'select'; isRequired: true; options: { choices: [{ "label": "Short"; "value": "short"; }, { "label": "Immersive"; "value": "immersive"; }, { "label": "Off"; "value": "off"; }]; }; }; /** Stage. */ 'stage': { label: 'Stage'; type: 'select'; options: { choices: [{ "label": "Create skill"; "value": "create.skill"; }, { "label": "Test"; "value": "test"; }]; }; }; }; } interface OnboardingEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** The question is; Are you read? ⚡️ */ interface OnboardOptions { } interface OnboardOptionsSchema extends SpruceSchema.Schema { id: 'onboardOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Onboard action'; description: 'The question is; Are you read? ⚡️'; fields: {}; } interface OnboardOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Create a new node module, to be written in typescript, ready to rock! */ interface NodeFeatureOptions { 'destination'?: string | undefined | null; /** What's the name of your module?. */ 'name': string; /** How would you describe your module?. */ 'description': string; } interface NodeFeatureOptionsSchema extends SpruceSchema.Schema { id: 'nodeFeatureOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Create node module'; description: 'Create a new node module, to be written in typescript, ready to rock!'; fields: { /** . */ 'destination': { type: 'text'; defaultValue: "."; options: undefined; }; /** What's the name of your module?. */ 'name': { label: 'What\'s the name of your module?'; type: 'text'; isRequired: true; options: undefined; }; /** How would you describe your module?. */ 'description': { label: 'How would you describe your module?'; type: 'text'; isRequired: true; options: undefined; }; }; } interface NodeFeatureOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Used to collect input on the names of a class or interface */ interface NamedTemplateItem { /** Readable name. The name people will read */ 'nameReadable': string; /** Readable name (plural). The plural form of the name people will read */ 'nameReadablePlural': string; /** Camel case name. camelCase version of the name */ 'nameCamel': string; /** Plural camel case name. camelCase version of the name */ 'nameCamelPlural'?: string | undefined | null; /** Pascal case name. PascalCase of the name */ 'namePascal'?: string | undefined | null; /** Plural Pascal case name. PascalCase of the name */ 'namePascalPlural'?: string | undefined | null; /** Constant case name. CONST_CASE of the name */ 'nameConst'?: string | undefined | null; /** Kebab case name. kebab-case of the name */ 'nameKebab'?: string | undefined | null; /** Snake case name. snake_case of the name */ 'nameSnake'?: string | undefined | null; /** Snake case name (plural). snakes_case of the name */ 'nameSnakePlural'?: string | undefined | null; /** Description. Describe a bit more here */ 'description'?: string | undefined | null; } interface NamedTemplateItemSchema extends SpruceSchema.Schema { id: 'namedTemplateItem'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'NamedTemplateItem'; description: 'Used to collect input on the names of a class or interface'; fields: { /** Readable name. The name people will read */ 'nameReadable': { label: 'Readable name'; type: 'text'; isRequired: true; hint: 'The name people will read'; options: undefined; }; /** Readable name (plural). The plural form of the name people will read */ 'nameReadablePlural': { label: 'Readable name (plural)'; type: 'text'; isRequired: true; hint: 'The plural form of the name people will read'; options: undefined; }; /** Camel case name. camelCase version of the name */ 'nameCamel': { label: 'Camel case name'; type: 'text'; isRequired: true; hint: 'camelCase version of the name'; options: undefined; }; /** Plural camel case name. camelCase version of the name */ 'nameCamelPlural': { label: 'Plural camel case name'; type: 'text'; hint: 'camelCase version of the name'; options: undefined; }; /** Pascal case name. PascalCase of the name */ 'namePascal': { label: 'Pascal case name'; type: 'text'; hint: 'PascalCase of the name'; options: undefined; }; /** Plural Pascal case name. PascalCase of the name */ 'namePascalPlural': { label: 'Plural Pascal case name'; type: 'text'; hint: 'PascalCase of the name'; options: undefined; }; /** Constant case name. CONST_CASE of the name */ 'nameConst': { label: 'Constant case name'; type: 'text'; hint: 'CONST_CASE of the name'; options: undefined; }; /** Kebab case name. kebab-case of the name */ 'nameKebab': { label: 'Kebab case name'; type: 'text'; hint: 'kebab-case of the name'; options: undefined; }; /** Snake case name. snake_case of the name */ 'nameSnake': { label: 'Snake case name'; type: 'text'; hint: 'snake_case of the name'; options: undefined; }; /** Snake case name (plural). snakes_case of the name */ 'nameSnakePlural': { label: 'Snake case name (plural)'; type: 'text'; hint: 'snakes_case of the name'; options: undefined; }; /** Description. Describe a bit more here */ 'description': { label: 'Description'; type: 'text'; hint: 'Describe a bit more here'; options: undefined; }; }; } interface NamedTemplateItemEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Options for event.listen. */ interface ListenEventOptions { /** Contract destination. Where I will generate event contracts. */ 'contractDestinationDir'?: string | undefined | null; /** Schema types lookup directory. Where I will lookup schema types and interfaces. */ 'schemaTypesLookupDir'?: string | undefined | null; /** Sync only core events. For use in @sprucelabs/mercury-types */ 'shouldSyncOnlyCoreEvents'?: boolean | undefined | null; /** Event signature types file. */ 'skillEventContractTypesFile'?: string | undefined | null; /** Event builder file. */ 'eventBuilderFile'?: string | undefined | null; /** Namespace. */ 'namespace'?: string | undefined | null; /** Event name. */ 'eventName'?: string | undefined | null; /** Events destination directory. Where should I add your listeners? */ 'listenerDestinationDir'?: string | undefined | null; /** Version. Set a version yourself instead of letting me generate one for you */ 'version'?: string | undefined | null; } interface ListenEventOptionsSchema extends SpruceSchema.Schema { id: 'listenEventOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Listen to event action'; description: 'Options for event.listen.'; fields: { /** Contract destination. Where I will generate event contracts. */ 'contractDestinationDir': { label: 'Contract destination'; type: 'text'; hint: 'Where I will generate event contracts.'; defaultValue: "#spruce/events"; options: undefined; }; /** Schema types lookup directory. Where I will lookup schema types and interfaces. */ 'schemaTypesLookupDir': { label: 'Schema types lookup directory'; type: 'text'; hint: 'Where I will lookup schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Sync only core events. For use in @sprucelabs/mercury-types */ 'shouldSyncOnlyCoreEvents': { label: 'Sync only core events'; type: 'boolean'; hint: 'For use in @sprucelabs/mercury-types'; options: undefined; }; /** Event signature types file. */ 'skillEventContractTypesFile': { label: 'Event signature types file'; type: 'text'; defaultValue: "@sprucelabs/mercury-types/build/types/mercury.types"; options: undefined; }; /** Event builder file. */ 'eventBuilderFile': { label: 'Event builder file'; type: 'text'; defaultValue: "@sprucelabs/mercury-types"; options: undefined; }; /** Namespace. */ 'namespace': { label: 'Namespace'; type: 'text'; options: undefined; }; /** Event name. */ 'eventName': { label: 'Event name'; type: 'text'; options: undefined; }; /** Events destination directory. Where should I add your listeners? */ 'listenerDestinationDir': { label: 'Events destination directory'; type: 'text'; hint: 'Where should I add your listeners?'; defaultValue: "src/listeners"; options: undefined; }; /** Version. Set a version yourself instead of letting me generate one for you */ 'version': { label: 'Version'; type: 'text'; isPrivate: true; hint: 'Set a version yourself instead of letting me generate one for you'; options: undefined; }; }; } interface ListenEventOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Install your skill at any organization you are connected to. */ interface InstallSkillAtOrganizationOptions { /** Organization id. */ 'organizationId'?: string | undefined | null; } interface InstallSkillAtOrganizationOptionsSchema extends SpruceSchema.Schema { id: 'installSkillAtOrganizationOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'install skill at organization action'; description: 'Install your skill at any organization you are connected to.'; fields: { /** Organization id. */ 'organizationId': { label: 'Organization id'; type: 'id'; options: undefined; }; }; } interface InstallSkillAtOrganizationOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Your first failing test just a command away! ⚔️ */ interface CreateTestOptions { /** Type of test. */ 'type': ("behavioral" | "implementation"); /** What are you testing?. E.g. Todo Card or Systems List */ 'nameReadable': string; /** Test destination directory. Where I'll save your new test. */ 'testDestinationDir'?: string | undefined | null; /** Camel case name. camelCase version of the name */ 'nameCamel': string; /** Pascal case name. PascalCase of the name */ 'namePascal'?: string | undefined | null; } interface CreateTestOptionsSchema extends SpruceSchema.Schema { id: 'createTestOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Create test action'; description: 'Your first failing test just a command away! ⚔️'; fields: { /** Type of test. */ 'type': { label: 'Type of test'; type: 'select'; isRequired: true; options: { choices: [{ "value": "behavioral"; "label": "Behavioral"; }, { "value": "implementation"; "label": "Implementation"; }]; }; }; /** What are you testing?. E.g. Todo Card or Systems List */ 'nameReadable': { label: 'What are you testing?'; type: 'text'; isRequired: true; hint: 'E.g. Todo Card or Systems List'; options: undefined; }; /** Test destination directory. Where I'll save your new test. */ 'testDestinationDir': { label: 'Test destination directory'; type: 'text'; hint: 'Where I\'ll save your new test.'; defaultValue: "src/__tests__"; options: undefined; }; /** Camel case name. camelCase version of the name */ 'nameCamel': { label: 'Camel case name'; type: 'text'; isRequired: true; hint: 'camelCase version of the name'; options: undefined; }; /** Pascal case name. PascalCase of the name */ 'namePascal': { label: 'Pascal case name'; type: 'text'; hint: 'PascalCase of the name'; options: undefined; }; }; } interface CreateTestOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Create the builder to a fresh new schema! */ interface CreateSchemaOptions { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir'?: string | undefined | null; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir'?: string | undefined | null; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes'?: boolean | undefined | null; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile'?: string | undefined | null; /** . Where I should look for your schema builders? */ 'schemaLookupDir'?: string | undefined | null; /** Source module. If this schema should be imported from a node module vs generated locally. */ 'moduleToImportFromWhenRemote'?: string | undefined | null; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies'?: boolean | undefined | null; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning'?: boolean | undefined | null; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace'?: string | undefined | null; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas'?: boolean | undefined | null; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas'?: boolean | undefined | null; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas'?: boolean | undefined | null; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes'?: boolean | undefined | null; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas'?: boolean | undefined | null; /** Delete directory if no schemas. Should I delete the schema directory if no schemas are found? */ 'deleteDestinationDirIfNoSchemas'?: boolean | undefined | null; /** Delete orphaned schemas. Should I delete schemas where the builders are missing? */ 'deleteOrphanedSchemas'?: boolean | undefined | null; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile'?: boolean | undefined | null; /** message. */ 'syncingMessage'?: string | undefined | null; /** Schema builder destination directory. Where I'll save the new schema builder. */ 'schemaBuilderDestinationDir'?: string | undefined | null; /** Builder function. The function that builds this schema */ 'builderFunction'?: string | undefined | null; /** Sync after creation. This will ensure types and schemas are in sync after you create your builder. */ 'syncAfterCreate'?: boolean | undefined | null; /** Version. Set a version yourself instead of letting me generate one for you */ 'version'?: string | undefined | null; /** Readable name. The name people will read */ 'nameReadable': string; /** Pascal case name. PascalCase of the name */ 'namePascal'?: string | undefined | null; /** Camel case name. camelCase version of the name */ 'nameCamel': string; /** Description. Describe a bit more here */ 'description'?: string | undefined | null; } interface CreateSchemaOptionsSchema extends SpruceSchema.Schema { id: 'createSchemaOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Create schema'; description: 'Create the builder to a fresh new schema!'; fields: { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir': { label: 'Field types directory'; type: 'text'; isPrivate: true; hint: 'Where field types and interfaces will be generated.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir': { label: 'Addons lookup directory'; type: 'text'; hint: 'Where I\'ll look for new schema fields to be registered.'; defaultValue: "src/addons"; options: undefined; }; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes': { label: 'Generate field types'; type: 'boolean'; isPrivate: true; hint: 'Should I generate field types too?'; defaultValue: true; options: undefined; }; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile': { label: 'Schema types destination directory'; type: 'text'; hint: 'Where I will generate schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** . Where I should look for your schema builders? */ 'schemaLookupDir': { type: 'text'; hint: 'Where I should look for your schema builders?'; defaultValue: "src/schemas"; options: undefined; }; /** Source module. If this schema should be imported from a node module vs generated locally. */ 'moduleToImportFromWhenRemote': { label: 'Source module'; type: 'text'; hint: 'If this schema should be imported from a node module vs generated locally.'; options: undefined; }; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies': { label: 'Auto install missing dependencies'; type: 'boolean'; options: undefined; }; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning': { label: 'Enable versioning'; type: 'boolean'; isPrivate: true; hint: 'Should we use versioning?'; defaultValue: true; options: undefined; }; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace': { label: 'Global namespace'; type: 'text'; isPrivate: true; hint: 'The name you\'ll use when accessing these schemas, e.g. SpruceSchemas'; defaultValue: "SpruceSchemas"; options: undefined; }; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas': { label: 'Fetch remote schemas'; type: 'boolean'; isPrivate: true; hint: 'I will pull in schemas from other features.'; defaultValue: true; options: undefined; }; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas': { label: 'Fetch local schemas'; type: 'boolean'; isPrivate: true; hint: 'I will look in schemaLookupDir to load local schemas.'; defaultValue: true; options: undefined; }; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas': { label: 'Fetch core schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I pull in core schemas too?'; defaultValue: true; options: undefined; }; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes': { label: 'Generate core schemas'; type: 'boolean'; isPrivate: true; hint: 'Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile.'; options: undefined; }; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas': { label: 'Register built schemas'; type: 'boolean'; isPrivate: true; hint: 'Should the schemas use the SchemaRegistry for tracking?'; defaultValue: true; options: undefined; }; /** Delete directory if no schemas. Should I delete the schema directory if no schemas are found? */ 'deleteDestinationDirIfNoSchemas': { label: 'Delete directory if no schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I delete the schema directory if no schemas are found?'; defaultValue: false; options: undefined; }; /** Delete orphaned schemas. Should I delete schemas where the builders are missing? */ 'deleteOrphanedSchemas': { label: 'Delete orphaned schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I delete schemas where the builders are missing?'; defaultValue: true; options: undefined; }; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile': { label: 'Generate standalone types file'; type: 'boolean'; isPrivate: true; hint: 'By default, I\'ll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file.'; defaultValue: false; options: undefined; }; /** message. */ 'syncingMessage': { label: ' message'; type: 'text'; isPrivate: true; defaultValue: "Syncing schemas..."; options: undefined; }; /** Schema builder destination directory. Where I'll save the new schema builder. */ 'schemaBuilderDestinationDir': { label: 'Schema builder destination directory'; type: 'text'; hint: 'Where I\'ll save the new schema builder.'; defaultValue: "src/schemas"; options: undefined; }; /** Builder function. The function that builds this schema */ 'builderFunction': { label: 'Builder function'; type: 'text'; isPrivate: true; hint: 'The function that builds this schema'; defaultValue: "buildSchema"; options: undefined; }; /** Sync after creation. This will ensure types and schemas are in sync after you create your builder. */ 'syncAfterCreate': { label: 'Sync after creation'; type: 'boolean'; isPrivate: true; hint: 'This will ensure types and schemas are in sync after you create your builder.'; defaultValue: true; options: undefined; }; /** Version. Set a version yourself instead of letting me generate one for you */ 'version': { label: 'Version'; type: 'text'; isPrivate: true; hint: 'Set a version yourself instead of letting me generate one for you'; options: undefined; }; /** Readable name. The name people will read */ 'nameReadable': { label: 'Readable name'; type: 'text'; isRequired: true; hint: 'The name people will read'; options: undefined; }; /** Pascal case name. PascalCase of the name */ 'namePascal': { label: 'Pascal case name'; type: 'text'; hint: 'PascalCase of the name'; options: undefined; }; /** Camel case name. camelCase version of the name */ 'nameCamel': { label: 'Camel case name'; type: 'text'; isRequired: true; hint: 'camelCase version of the name'; options: undefined; }; /** Description. Describe a bit more here */ 'description': { label: 'Description'; type: 'text'; hint: 'Describe a bit more here'; options: undefined; }; }; } interface CreateSchemaOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Skills can only communicate with people and skills associated with the same organization. This ensures people can get differentiated experiences across multiple businesses. */ interface CreateOrganizationOptions { /** Name. The name people will read */ 'nameReadable': string; /** Slug. kebab-case of the name */ 'nameKebab'?: string | undefined | null; } interface CreateOrganizationOptionsSchema extends SpruceSchema.Schema { id: 'createOrganizationOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'create organization action'; description: 'Skills can only communicate with people and skills associated with the same organization. This ensures people can get differentiated experiences across multiple businesses.'; fields: { /** Name. The name people will read */ 'nameReadable': { label: 'Name'; type: 'text'; isRequired: true; hint: 'The name people will read'; options: undefined; }; /** Slug. kebab-case of the name */ 'nameKebab': { label: 'Slug'; type: 'text'; hint: 'kebab-case of the name'; options: undefined; }; }; } interface CreateOrganizationOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Create a builder for your brand new error! */ interface CreateErrorOptions { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir'?: string | undefined | null; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir'?: string | undefined | null; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes'?: boolean | undefined | null; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile'?: string | undefined | null; /** . Where I should look for your schema builders? */ 'schemaLookupDir'?: string | undefined | null; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote'?: string | undefined | null; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies'?: boolean | undefined | null; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning'?: boolean | undefined | null; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace'?: string | undefined | null; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas'?: boolean | undefined | null; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas'?: boolean | undefined | null; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas'?: boolean | undefined | null; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes'?: boolean | undefined | null; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas'?: boolean | undefined | null; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile'?: boolean | undefined | null; /** message. */ 'syncingMessage'?: string | undefined | null; /** Error class destination. Where I'll save your new Error class file? */ 'errorClassDestinationDir': string; /** . Where I should look for your error builders? */ 'errorLookupDir'?: string | undefined | null; /** Types destination dir. This is where error options and type information will be written */ 'errorTypesDestinationDir'?: string | undefined | null; /** Error builder destination directory. Where I'll save your new builder file? */ 'errorBuilderDestinationDir': string; /** Readable name. The name people will read */ 'nameReadable': string; /** Pascal case name. PascalCase of the name */ 'namePascal'?: string | undefined | null; /** Camel case name. camelCase version of the name */ 'nameCamel': string; /** Description. Describe a bit more here */ 'description'?: string | undefined | null; } interface CreateErrorOptionsSchema extends SpruceSchema.Schema { id: 'createErrorOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Create error action'; description: 'Create a builder for your brand new error! '; fields: { /** Field types directory. Where field types and interfaces will be generated. */ 'fieldTypesDestinationDir': { label: 'Field types directory'; type: 'text'; isPrivate: true; hint: 'Where field types and interfaces will be generated.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** Addons lookup directory. Where I'll look for new schema fields to be registered. */ 'addonsLookupDir': { label: 'Addons lookup directory'; type: 'text'; hint: 'Where I\'ll look for new schema fields to be registered.'; defaultValue: "src/addons"; options: undefined; }; /** Generate field types. Should I generate field types too? */ 'generateFieldTypes': { label: 'Generate field types'; type: 'boolean'; isPrivate: true; hint: 'Should I generate field types too?'; defaultValue: true; options: undefined; }; /** Schema types destination directory. Where I will generate schema types and interfaces. */ 'schemaTypesDestinationDirOrFile': { label: 'Schema types destination directory'; type: 'text'; hint: 'Where I will generate schema types and interfaces.'; defaultValue: "#spruce/schemas"; options: undefined; }; /** . Where I should look for your schema builders? */ 'schemaLookupDir': { type: 'text'; hint: 'Where I should look for your schema builders?'; defaultValue: "src/schemas"; options: undefined; }; /** Module import. When other skills use your schemas, will they import them from a module? */ 'moduleToImportFromWhenRemote': { label: 'Module import'; type: 'text'; hint: 'When other skills use your schemas, will they import them from a module?'; options: undefined; }; /** Auto install missing dependencies. */ 'shouldInstallMissingDependencies': { label: 'Auto install missing dependencies'; type: 'boolean'; options: undefined; }; /** Enable versioning. Should we use versioning? */ 'shouldEnableVersioning': { label: 'Enable versioning'; type: 'boolean'; isPrivate: true; hint: 'Should we use versioning?'; defaultValue: true; options: undefined; }; /** Global namespace. The name you'll use when accessing these schemas, e.g. SpruceSchemas */ 'globalSchemaNamespace': { label: 'Global namespace'; type: 'text'; isPrivate: true; hint: 'The name you\'ll use when accessing these schemas, e.g. SpruceSchemas'; defaultValue: "SpruceSchemas"; options: undefined; }; /** Fetch remote schemas. I will pull in schemas from other features. */ 'shouldFetchRemoteSchemas': { label: 'Fetch remote schemas'; type: 'boolean'; isPrivate: true; hint: 'I will pull in schemas from other features.'; defaultValue: true; options: undefined; }; /** Fetch local schemas. I will look in schemaLookupDir to load local schemas. */ 'shouldFetchLocalSchemas': { label: 'Fetch local schemas'; type: 'boolean'; isPrivate: true; hint: 'I will look in schemaLookupDir to load local schemas.'; defaultValue: true; options: undefined; }; /** Fetch core schemas. Should I pull in core schemas too? */ 'shouldFetchCoreSchemas': { label: 'Fetch core schemas'; type: 'boolean'; isPrivate: true; hint: 'Should I pull in core schemas too?'; defaultValue: true; options: undefined; }; /** Generate core schemas. Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile. */ 'shouldGenerateCoreSchemaTypes': { label: 'Generate core schemas'; type: 'boolean'; isPrivate: true; hint: 'Used only for updating the @sprucelabs/spruce-core-schemas. Ensures core schemas are generated like local schemas. Also an alias for `--shouldFetchRemoteSchemas=false --shouldFetchCoreSchemas=false --generateStandaloneTypesFile.'; options: undefined; }; /** Register built schemas. Should the schemas use the SchemaRegistry for tracking? */ 'registerBuiltSchemas': { label: 'Register built schemas'; type: 'boolean'; isPrivate: true; hint: 'Should the schemas use the SchemaRegistry for tracking?'; defaultValue: true; options: undefined; }; /** Generate standalone types file. By default, I'll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file. */ 'generateStandaloneTypesFile': { label: 'Generate standalone types file'; type: 'boolean'; isPrivate: true; hint: 'By default, I\'ll generate a types file that augments core types from @sprucelabs/spruce-core-schemas. Setting this to true will generate a stand alone types file.'; defaultValue: false; options: undefined; }; /** message. */ 'syncingMessage': { label: ' message'; type: 'text'; isPrivate: true; defaultValue: "Syncing schemas..."; options: undefined; }; /** Error class destination. Where I'll save your new Error class file? */ 'errorClassDestinationDir': { label: 'Error class destination'; type: 'text'; isPrivate: true; isRequired: true; hint: 'Where I\'ll save your new Error class file?'; defaultValue: "src/errors"; options: undefined; }; /** . Where I should look for your error builders? */ 'errorLookupDir': { type: 'text'; hint: 'Where I should look for your error builders?'; defaultValue: "src/errors"; options: undefined; }; /** Types destination dir. This is where error options and type information will be written */ 'errorTypesDestinationDir': { label: 'Types destination dir'; type: 'text'; hint: 'This is where error options and type information will be written'; defaultValue: "#spruce/errors"; options: undefined; }; /** Error builder destination directory. Where I'll save your new builder file? */ 'errorBuilderDestinationDir': { label: 'Error builder destination directory'; type: 'text'; isPrivate: true; isRequired: true; hint: 'Where I\'ll save your new builder file?'; defaultValue: "./src/errors"; options: undefined; }; /** Readable name. The name people will read */ 'nameReadable': { label: 'Readable name'; type: 'text'; isRequired: true; hint: 'The name people will read'; options: undefined; }; /** Pascal case name. PascalCase of the name */ 'namePascal': { label: 'Pascal case name'; type: 'text'; hint: 'PascalCase of the name'; options: undefined; }; /** Camel case name. camelCase version of the name */ 'nameCamel': { label: 'Camel case name'; type: 'text'; isRequired: true; hint: 'camelCase version of the name'; options: undefined; }; /** Description. Describe a bit more here */ 'description': { label: 'Description'; type: 'text'; hint: 'Describe a bit more here'; options: undefined; }; }; } interface CreateErrorOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Define a topic you want to discuss. */ interface CreateConversationTopicOptions { /** Topic. What should we talk about or try and get done, e.g. Book an appointment or tell a knock knock joke. */ 'nameReadable': string; /** Camel case name. camelCase version of the name */ 'nameCamel': string; } interface CreateConversationTopicOptionsSchema extends SpruceSchema.Schema { id: 'createConversationTopicOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Create conversation options'; description: 'Define a topic you want to discuss.'; fields: { /** Topic. What should we talk about or try and get done, e.g. Book an appointment or tell a knock knock joke. */ 'nameReadable': { label: 'Topic'; type: 'text'; isRequired: true; hint: 'What should we talk about or try and get done, e.g. Book an appointment or tell a knock knock joke.'; options: undefined; }; /** Camel case name. camelCase version of the name */ 'nameCamel': { label: 'Camel case name'; type: 'text'; isRequired: true; hint: 'camelCase version of the name'; options: undefined; }; }; } interface CreateConversationTopicOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { /** Boot your skill 💪 */ interface BootSkillOptions { /** Run local. Will run using ts-node and typescript directly. Longer boot times */ 'local'?: boolean | undefined | null; 'onData'?: ((msg: string) => void) | undefined | null; 'onError'?: ((msg: string) => void) | undefined | null; /** Wait until skill is booted. For testing. Returns immediately after executing test so the running tests can be managed programatically. */ 'shouldReturnImmediately'?: boolean | undefined | null; } interface BootSkillOptionsSchema extends SpruceSchema.Schema { id: 'bootSkillOptions'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Boot skill action'; description: 'Boot your skill 💪'; fields: { /** Run local. Will run using ts-node and typescript directly. Longer boot times */ 'local': { label: 'Run local'; type: 'boolean'; hint: 'Will run using ts-node and typescript directly. Longer boot times'; options: undefined; }; /** . */ 'onData': { type: 'raw'; options: { valueType: `(msg: string) => void`; }; }; /** . */ 'onError': { type: 'raw'; options: { valueType: `(msg: string) => void`; }; }; /** Wait until skill is booted. For testing. Returns immediately after executing test so the running tests can be managed programatically. */ 'shouldReturnImmediately': { label: 'Wait until skill is booted'; type: 'boolean'; isPrivate: true; hint: 'For testing. Returns immediately after executing test so the running tests can be managed programatically.'; defaultValue: false; options: undefined; }; }; } interface BootSkillOptionsEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface NpmPackage { 'name': string; 'version'?: string | undefined | null; 'isDev'?: boolean | undefined | null; } interface NpmPackageSchema extends SpruceSchema.Schema { id: 'npmPackage'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: ''; fields: { /** . */ 'name': { type: 'text'; isRequired: true; options: undefined; }; /** . */ 'version': { type: 'text'; options: undefined; }; /** . */ 'isDev': { type: 'boolean'; options: undefined; }; }; } interface NpmPackageEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface GeneratedFile { 'name': string; 'path': string; 'description'?: string | undefined | null; 'action': ("skipped" | "generated" | "updated" | "deleted"); } interface GeneratedFileSchema extends SpruceSchema.Schema { id: 'generatedFile'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: ''; fields: { /** . */ 'name': { type: 'text'; isRequired: true; options: undefined; }; /** . */ 'path': { type: 'text'; isRequired: true; options: undefined; }; /** . */ 'description': { type: 'text'; options: undefined; }; /** . */ 'action': { type: 'select'; isRequired: true; options: { choices: [{ "label": "Skipped"; "value": "skipped"; }, { "label": "Generated"; "value": "generated"; }, { "label": "Updated"; "value": "updated"; }, { "label": "Deleted"; "value": "deleted"; }]; }; }; }; } interface GeneratedFileEntity extends SchemaEntity { } } namespace SpruceSchemas.SpruceCli.v2020_07_22 { interface ActionResponse { 'files'?: SpruceSchemas.SpruceCli.v2020_07_22.GeneratedFile[] | undefined | null; 'headline'?: string | undefined | null; 'hints'?: string[] | undefined | null; 'summaryLines'?: string[] | undefined | null; 'errors'?: (AbstractSpruceError)[] | undefined | null; 'meta'?: (Record) | undefined | null; 'packagesInstalled'?: SpruceSchemas.SpruceCli.v2020_07_22.NpmPackage[] | undefined | null; } interface ActionResponseSchema extends SpruceSchema.Schema { id: 'actionResponse'; version: 'v2020_07_22'; namespace: 'SpruceCli'; name: 'Action response'; fields: { /** . */ 'files': { type: 'schema'; isArray: true; options: { schema: SpruceSchemas.SpruceCli.v2020_07_22.GeneratedFileSchema; }; }; /** . */ 'headline': { type: 'text'; options: undefined; }; /** . */ 'hints': { type: 'text'; isArray: true; options: undefined; }; /** . */ 'summaryLines': { type: 'text'; isArray: true; options: undefined; }; /** . */ 'errors': { type: 'raw'; isArray: true; options: { valueType: `AbstractSpruceError`; }; }; /** . */ 'meta': { type: 'raw'; options: { valueType: `Record`; }; }; /** . */ 'packagesInstalled': { type: 'schema'; isArray: true; options: { schema: SpruceSchemas.SpruceCli.v2020_07_22.NpmPackageSchema; }; }; }; } interface ActionResponseEntity extends SchemaEntity { } } }