@minecraft/api-docs-generator 1.0.0

package/lib/modules/IMinecraftModule.d.ts

@@ -0,0 +1,123 @@
+import { Array, Boolean, Intersect, Literal, Optional, Record, Runtype, Static, String, Union } from 'runtypes';
+/**
+ * The supported module types for documentation generation.
+ */
+export declare const ModuleTypesValidator: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+export type ModuleTypes = Static<typeof ModuleTypesValidator>;
+/**
+ * Most common piece of data for generation, a name field.
+ */
+export declare const ModuleNameDataValidator: Record<{
+    name: String;
+}, false>;
+export type ModuleNameData = Static<typeof ModuleNameDataValidator>;
+/**
+ * Common module data for all types of modules
+ */
+export declare const CommonModuleDataValidator: Record<{
+    name: String;
+    minecraft_version: String;
+    module_type: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+    module_name: Optional<String>;
+}, false>;
+export type IMinecraftModule = Static<typeof CommonModuleDataValidator>;
+/**
+ * Common data for runtime comment flags
+ */
+export declare const CommonCommentFlagsValidator: Record<{
+    has_comments: Optional<Boolean>;
+}, false>;
+/**
+ * Standardized Vanilla Name Record and optional states
+ */
+export declare const StandardizedVanillaNameRecord: Record<{
+    namespace: Optional<String>;
+    no_namespace_name: Optional<String>;
+    standardized_name: Optional<String>;
+}, false>;
+/**
+ * Additional data that may be associated with data_items
+ */
+export declare const DataStateRecord: Record<{
+    properties: Optional<Array<Record<{
+        name: String;
+    }, false>, false>>;
+    state_union: Optional<String>;
+    value: Optional<String>;
+}, false>;
+/**
+ * Runtime specific fields for module name data in vanilla data modules
+ */
+export declare const VanillaModuleNameDataValidator: Intersect<[Intersect<[Record<{
+    name: String;
+}, false>, Record<{
+    namespace: Optional<String>;
+    no_namespace_name: Optional<String>;
+    standardized_name: Optional<String>;
+}, false>]>, Record<{
+    properties: Optional<Array<Record<{
+        name: String;
+    }, false>, false>>;
+    state_union: Optional<String>;
+    value: Optional<String>;
+}, false>]>;
+export type VanillaModuleNameData = Static<typeof VanillaModuleNameDataValidator>;
+export declare const CoreVanillaDataFieldsRecord: Intersect<[Record<{
+    data_items: Array<Intersect<[Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        namespace: Optional<String>;
+        no_namespace_name: Optional<String>;
+        standardized_name: Optional<String>;
+    }, false>]>, Record<{
+        properties: Optional<Array<Record<{
+            name: String;
+        }, false>, false>>;
+        state_union: Optional<String>;
+        value: Optional<String>;
+    }, false>]>, false>;
+    vanilla_data_type: Optional<String>;
+    module_type: Literal<"vanilla_data">;
+    display_type: Optional<String>;
+    display_name: Optional<String>;
+    has_properties: Optional<Boolean>;
+}, false>, Record<{
+    name: String;
+    minecraft_version: String;
+    module_type: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+    module_name: Optional<String>;
+}, false>]>;
+export type CoreVanillaDataFields = Static<typeof CoreVanillaDataFieldsRecord>;
+/**
+ * Common vanilla data fields for all types of modules
+ */
+export declare function getCommonVanillaDataFieldsRecord<T extends Runtype>(base: T, literalType: string): Intersect<[Intersect<[Record<{
+    data_items: Array<Intersect<[Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        namespace: Optional<String>;
+        no_namespace_name: Optional<String>;
+        standardized_name: Optional<String>;
+    }, false>]>, Record<{
+        properties: Optional<Array<Record<{
+            name: String;
+        }, false>, false>>;
+        state_union: Optional<String>;
+        value: Optional<String>;
+    }, false>]>, false>;
+    vanilla_data_type: Optional<String>;
+    module_type: Literal<"vanilla_data">;
+    display_type: Optional<String>;
+    display_name: Optional<String>;
+    has_properties: Optional<Boolean>;
+}, false>, Record<{
+    name: String;
+    minecraft_version: String;
+    module_type: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+    module_name: Optional<String>;
+}, false>]>, Record<{
+    data_items: Array<T, false>;
+    vanilla_data_type: Optional<Literal<string>>;
+}, false>]>;
+export type CommonVanillaDataFields = Static<ReturnType<typeof getCommonVanillaDataFieldsRecord>>;
+export type RuntimeDataModule<T> = T extends IMinecraftModule ? T : never;

package/lib/modules/IMinecraftModule.js

@@ -0,0 +1,71 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreVanillaDataFieldsRecord = exports.VanillaModuleNameDataValidator = exports.DataStateRecord = exports.StandardizedVanillaNameRecord = exports.CommonCommentFlagsValidator = exports.CommonModuleDataValidator = exports.ModuleNameDataValidator = exports.ModuleTypesValidator = void 0;
+exports.getCommonVanillaDataFieldsRecord = getCommonVanillaDataFieldsRecord;
+const runtypes_1 = require("runtypes");
+/**
+ * The supported module types for documentation generation.
+ */
+exports.ModuleTypesValidator = (0, runtypes_1.Union)((0, runtypes_1.Literal)('script'), (0, runtypes_1.Literal)('commands'), (0, runtypes_1.Literal)('after_events_ordering'), (0, runtypes_1.Literal)('vanilla_data'));
+/**
+ * Most common piece of data for generation, a name field.
+ */
+exports.ModuleNameDataValidator = (0, runtypes_1.Record)({
+    name: runtypes_1.String,
+});
+/**
+ * Common module data for all types of modules
+ */
+exports.CommonModuleDataValidator = (0, runtypes_1.Record)({
+    name: runtypes_1.String,
+    minecraft_version: runtypes_1.String,
+    module_type: exports.ModuleTypesValidator,
+    module_name: (0, runtypes_1.Optional)(runtypes_1.String),
+});
+/**
+ * Common data for runtime comment flags
+ */
+exports.CommonCommentFlagsValidator = (0, runtypes_1.Record)({
+    has_comments: (0, runtypes_1.Optional)(runtypes_1.Boolean),
+});
+/**
+ * Standardized Vanilla Name Record and optional states
+ */
+exports.StandardizedVanillaNameRecord = (0, runtypes_1.Record)({
+    namespace: (0, runtypes_1.Optional)(runtypes_1.String),
+    no_namespace_name: (0, runtypes_1.Optional)(runtypes_1.String),
+    standardized_name: (0, runtypes_1.Optional)(runtypes_1.String),
+});
+/**
+ * Additional data that may be associated with data_items
+ */
+exports.DataStateRecord = (0, runtypes_1.Record)({
+    properties: (0, runtypes_1.Optional)((0, runtypes_1.Array)(exports.ModuleNameDataValidator)),
+    state_union: (0, runtypes_1.Optional)(runtypes_1.String),
+    value: (0, runtypes_1.Optional)(runtypes_1.String),
+});
+/**
+ * Runtime specific fields for module name data in vanilla data modules
+ */
+exports.VanillaModuleNameDataValidator = exports.ModuleNameDataValidator.And(exports.StandardizedVanillaNameRecord).And(exports.DataStateRecord);
+exports.CoreVanillaDataFieldsRecord = (0, runtypes_1.Intersect)((0, runtypes_1.Record)({
+    data_items: (0, runtypes_1.Array)(exports.VanillaModuleNameDataValidator),
+    vanilla_data_type: (0, runtypes_1.Optional)(runtypes_1.String),
+    module_type: (0, runtypes_1.Literal)('vanilla_data'),
+    // Runtime Markup
+    display_type: (0, runtypes_1.Optional)(runtypes_1.String),
+    display_name: (0, runtypes_1.Optional)(runtypes_1.String),
+    has_properties: (0, runtypes_1.Optional)(runtypes_1.Boolean),
+}), exports.CommonModuleDataValidator);
+/**
+ * Common vanilla data fields for all types of modules
+ */
+function getCommonVanillaDataFieldsRecord(base, literalType) {
+    return (0, runtypes_1.Intersect)(exports.CoreVanillaDataFieldsRecord, (0, runtypes_1.Record)({
+        data_items: (0, runtypes_1.Array)(base),
+        vanilla_data_type: (0, runtypes_1.Optional)((0, runtypes_1.Literal)(literalType)),
+    }));
+}
+//# sourceMappingURL=IMinecraftModule.js.map

package/lib/modules/IMinecraftModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMinecraftModule.js","sourceRoot":"","sources":["../../src/modules/IMinecraftModule.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAoFlC,4EAQC;AA1FD,uCAAgH;AAEhH;;GAEG;AACU,QAAA,oBAAoB,GAAG,IAAA,gBAAK,EACrC,IAAA,kBAAO,EAAC,QAAQ,CAAC,EACjB,IAAA,kBAAO,EAAC,UAAU,CAAC,EACnB,IAAA,kBAAO,EAAC,uBAAuB,CAAC,EAChC,IAAA,kBAAO,EAAC,cAAc,CAAC,CAC1B,CAAC;AAGF;;GAEG;AACU,QAAA,uBAAuB,GAAG,IAAA,iBAAM,EAAC;IAC1C,IAAI,EAAE,iBAAM;CACf,CAAC,CAAC;AAGH;;GAEG;AACU,QAAA,yBAAyB,GAAG,IAAA,iBAAM,EAAC;IAC5C,IAAI,EAAE,iBAAM;IACZ,iBAAiB,EAAE,iBAAM;IACzB,WAAW,EAAE,4BAAoB;IACjC,WAAW,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;CAChC,CAAC,CAAC;AAGH;;GAEG;AACU,QAAA,2BAA2B,GAAG,IAAA,iBAAM,EAAC;IAC9C,YAAY,EAAE,IAAA,mBAAQ,EAAC,kBAAO,CAAC;CAClC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,6BAA6B,GAAG,IAAA,iBAAM,EAAC;IAChD,SAAS,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC3B,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IACnC,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;CACtC,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,eAAe,GAAG,IAAA,iBAAM,EAAC;IAClC,UAAU,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,+BAAuB,CAAC,CAAC;IACpD,WAAW,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC7B,KAAK,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;CAC1B,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,8BAA8B,GACvC,+BAAuB,CAAC,GAAG,CAAC,qCAA6B,CAAC,CAAC,GAAG,CAAC,uBAAe,CAAC,CAAC;AAGvE,QAAA,2BAA2B,GAAG,IAAA,oBAAS,EAChD,IAAA,iBAAM,EAAC;IACH,UAAU,EAAE,IAAA,gBAAK,EAAC,sCAA8B,CAAC;IACjD,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IACnC,WAAW,EAAE,IAAA,kBAAO,EAAC,cAAc,CAAC;IAEpC,iBAAiB;IACjB,YAAY,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC9B,YAAY,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC9B,cAAc,EAAE,IAAA,mBAAQ,EAAC,kBAAO,CAAC;CACpC,CAAC,EACF,iCAAyB,CAC5B,CAAC;AAGF;;GAEG;AACH,SAAgB,gCAAgC,CAAoB,IAAO,EAAE,WAAmB;IAC5F,OAAO,IAAA,oBAAS,EACZ,mCAA2B,EAC3B,IAAA,iBAAM,EAAC;QACH,UAAU,EAAE,IAAA,gBAAK,EAAC,IAAI,CAAC;QACvB,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,IAAA,kBAAO,EAAC,WAAW,CAAC,CAAC;KACpD,CAAC,CACL,CAAC;AACN,CAAC"}

package/lib/modules/KeyToTypeMapping.d.ts

@@ -0,0 +1,77 @@
+import { ModuleNameData } from './IMinecraftModule';
+import { MinecraftBlockProperty } from './MinecraftBlockModule';
+import { MinecraftClassChangelogEntry, MinecraftConstantChangelogEntry, MinecraftEnumChangelogEntry, MinecraftErrorChangelogEntry, MinecraftFunctionChangelogEntry, MinecraftInterfaceChangelogEntry, MinecraftObjectChangelogEntry, MinecraftPropertyChangelogEntry, MinecraftTypeAliasChangelogEntry } from './MinecraftChangelogTypes';
+import { MinecraftClass, MinecraftClosureType, MinecraftConstant, MinecraftEnum, MinecraftError, MinecraftFunction, MinecraftFunctionArgument, MinecraftFunctionArgumentDetails, MinecraftGeneratorType, MinecraftInterface, MinecraftModuleDescription, MinecraftProperty, MinecraftType, MinecraftTypeAlias, NameMarkupType, VersionMarkupType } from './MinecraftScriptModule';
+/**
+ * Object property keys -> The type of the property
+ */
+export type KeyToTypeMapping = {
+    name: string;
+    version: string;
+    minecraft_version: string;
+    from_module: MinecraftModuleDescription;
+    module: MinecraftModuleDescription;
+    classes: MinecraftClass[];
+    constants: MinecraftConstant[];
+    enums: MinecraftEnum[];
+    errors: MinecraftError[];
+    functions: MinecraftFunction[];
+    interfaces: MinecraftInterface[];
+    properties: MinecraftProperty[];
+    type_aliases: MinecraftTypeAlias[];
+    details: MinecraftFunctionArgumentDetails;
+    default_value: unknown;
+    supported_values: unknown;
+    get_privilege: string[];
+    set_privilege: string[];
+    call_privilege: string[];
+    value: string;
+    is_static: boolean;
+    runtime_conditions: string[];
+    type: MinecraftType;
+    argument_types: MinecraftType[];
+    base_types: MinecraftType[];
+    closure_type: MinecraftClosureType;
+    derived_types: MinecraftType[];
+    element_type: MinecraftType;
+    error_types: MinecraftType[];
+    iterator: MinecraftType;
+    iterator_type: MinecraftType;
+    key_type: MinecraftType;
+    optional_type: MinecraftType;
+    promise_type: MinecraftType;
+    return_type: MinecraftType;
+    value_type: MinecraftType;
+    variant_types: MinecraftType[];
+    generator_type: MinecraftGeneratorType;
+    yield_type: MinecraftType;
+    next_type: MinecraftType;
+    changelog: never;
+    class_changelog: MinecraftClassChangelogEntry[];
+    interface_changelog: MinecraftInterfaceChangelogEntry[];
+    error_changelog: MinecraftErrorChangelogEntry[];
+    object_changelog: MinecraftObjectChangelogEntry[];
+    function_changelog: MinecraftFunctionChangelogEntry[];
+    constant_changelog: MinecraftConstantChangelogEntry[];
+    property_changelog: MinecraftPropertyChangelogEntry[];
+    enum_changelog: MinecraftEnumChangelogEntry[];
+    alias_changelog: MinecraftTypeAliasChangelogEntry[];
+    $added: boolean;
+    $removed: boolean;
+    $changed: boolean;
+    data_items: ModuleNameData[];
+    block_properties: MinecraftBlockProperty[];
+};
+/**
+ * Object property keys -> The type of the parent containing this property
+ *
+ * If a key exists in this map, scanObject functions will return this type instead of a Record containing only the property.
+ * Useful for when a filter needs to add other properties based on the presence of this key.
+ */
+export type KeyToParentTypeMapping = {
+    name: NameMarkupType;
+    version: VersionMarkupType;
+    iterator: MinecraftClass;
+    details: MinecraftFunctionArgument;
+    is_static: MinecraftConstant;
+};

package/lib/modules/KeyToTypeMapping.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=KeyToTypeMapping.js.map

package/lib/modules/KeyToTypeMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyToTypeMapping.js","sourceRoot":"","sources":["../../src/modules/KeyToTypeMapping.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC"}

package/lib/modules/MinecraftAfterEventsOrderModule.d.ts

@@ -0,0 +1,57 @@
+import { Array, Boolean, Intersect, Literal, Optional, Record, Static, String, Union } from 'runtypes';
+import { IMinecraftModule, RuntimeDataModule } from './IMinecraftModule';
+import { MinecraftEngineDataModule } from './MinecraftEngineDataModules';
+export declare const afterEventsOrderModuleName = "engine-after_events_ordering";
+export declare function getAfterEventsOrderingModuleFrom(engineModuleArray: RuntimeDataModule<MinecraftEngineDataModule>[]): {
+    name: string;
+    minecraft_version: string;
+    module_type: "script" | "commands" | "after_events_ordering" | "vanilla_data";
+    module_name?: string;
+} & {
+    module_type: "after_events_ordering";
+    after_events_order_by_version: ({
+        name: string;
+    } & {
+        version: string;
+        event_order: {
+            name: string;
+        }[];
+        version_is_prerelease?: boolean;
+        module_prerelease_tag?: "alpha" | "beta" | "internal" | "preview" | "rc";
+    })[];
+};
+export declare const MinecraftAfterEventOrderRecord: Record<{
+    name: String;
+}, false>;
+export type MinecraftEventOrder = Static<typeof MinecraftAfterEventOrderRecord>;
+export declare const MinecraftAfterEventsOrderByVersionRecord: Intersect<[Record<{
+    name: String;
+}, false>, Record<{
+    version_is_prerelease: Optional<Boolean>;
+    module_prerelease_tag: Optional<Union<[Literal<"alpha">, Literal<"beta">, Literal<"internal">, Literal<"preview">, Literal<"rc">]>>;
+    version: String;
+    event_order: Array<Record<{
+        name: String;
+    }, false>, false>;
+}, false>]>;
+export type MinecraftAfterEventsOrderByVersion = Static<typeof MinecraftAfterEventsOrderByVersionRecord>;
+export declare const MinecraftAfterEventsOrderModuleRecord: Intersect<[Record<{
+    name: String;
+    minecraft_version: String;
+    module_type: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+    module_name: Optional<String>;
+}, false>, Record<{
+    module_type: Literal<"after_events_ordering">;
+    after_events_order_by_version: Array<Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        version_is_prerelease: Optional<Boolean>;
+        module_prerelease_tag: Optional<Union<[Literal<"alpha">, Literal<"beta">, Literal<"internal">, Literal<"preview">, Literal<"rc">]>>;
+        version: String;
+        event_order: Array<Record<{
+            name: String;
+        }, false>, false>;
+    }, false>]>, false>;
+}, false>]>;
+export type MinecraftAfterEventsOrderModule = Static<typeof MinecraftAfterEventsOrderModuleRecord>;
+export declare function isAfterEventsOrderModule(module: IMinecraftModule): module is MinecraftAfterEventsOrderModule;

package/lib/modules/MinecraftAfterEventsOrderModule.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinecraftAfterEventsOrderModuleRecord = exports.MinecraftAfterEventsOrderByVersionRecord = exports.MinecraftAfterEventOrderRecord = exports.afterEventsOrderModuleName = void 0;
+exports.getAfterEventsOrderingModuleFrom = getAfterEventsOrderingModuleFrom;
+exports.isAfterEventsOrderModule = isAfterEventsOrderModule;
+const runtypes_1 = require("runtypes");
+const IMinecraftModule_1 = require("./IMinecraftModule");
+exports.afterEventsOrderModuleName = 'engine-after_events_ordering';
+function getAfterEventsOrderingModuleFrom(engineModuleArray) {
+    return engineModuleArray.find(module => module.name === exports.afterEventsOrderModuleName);
+}
+exports.MinecraftAfterEventOrderRecord = (0, runtypes_1.Record)({ name: runtypes_1.String });
+exports.MinecraftAfterEventsOrderByVersionRecord = (0, runtypes_1.Intersect)(IMinecraftModule_1.ModuleNameDataValidator, (0, runtypes_1.Record)({
+    version_is_prerelease: (0, runtypes_1.Optional)(runtypes_1.Boolean),
+    module_prerelease_tag: (0, runtypes_1.Optional)((0, runtypes_1.Union)((0, runtypes_1.Literal)('alpha'), (0, runtypes_1.Literal)('beta'), (0, runtypes_1.Literal)('internal'), (0, runtypes_1.Literal)('preview'), (0, runtypes_1.Literal)('rc'))),
+    version: runtypes_1.String,
+    event_order: (0, runtypes_1.Array)(exports.MinecraftAfterEventOrderRecord),
+}));
+exports.MinecraftAfterEventsOrderModuleRecord = (0, runtypes_1.Intersect)(IMinecraftModule_1.CommonModuleDataValidator, (0, runtypes_1.Record)({
+    module_type: (0, runtypes_1.Literal)('after_events_ordering'),
+    after_events_order_by_version: (0, runtypes_1.Array)(exports.MinecraftAfterEventsOrderByVersionRecord),
+}));
+function isAfterEventsOrderModule(module) {
+    return module !== undefined && module.module_type === 'after_events_ordering';
+}
+//# sourceMappingURL=MinecraftAfterEventsOrderModule.js.map

package/lib/modules/MinecraftAfterEventsOrderModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinecraftAfterEventsOrderModule.js","sourceRoot":"","sources":["../../src/modules/MinecraftAfterEventsOrderModule.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAalC,4EAEC;AA4BD,4DAEC;AA3CD,uCAAuG;AAEvG,yDAK4B;AAGf,QAAA,0BAA0B,GAAG,8BAA8B,CAAC;AACzE,SAAgB,gCAAgC,CAAC,iBAAiE;IAC9G,OAAO,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,kCAA0B,CAAC,CAAC;AACxF,CAAC;AAEY,QAAA,8BAA8B,GAAG,IAAA,iBAAM,EAAC,EAAE,IAAI,EAAE,iBAAM,EAAE,CAAC,CAAC;AAG1D,QAAA,wCAAwC,GAAG,IAAA,oBAAS,EAC7D,0CAAuB,EACvB,IAAA,iBAAM,EAAC;IACH,qBAAqB,EAAE,IAAA,mBAAQ,EAAC,kBAAO,CAAC;IACxC,qBAAqB,EAAE,IAAA,mBAAQ,EAC3B,IAAA,gBAAK,EAAC,IAAA,kBAAO,EAAC,OAAO,CAAC,EAAE,IAAA,kBAAO,EAAC,MAAM,CAAC,EAAE,IAAA,kBAAO,EAAC,UAAU,CAAC,EAAE,IAAA,kBAAO,EAAC,SAAS,CAAC,EAAE,IAAA,kBAAO,EAAC,IAAI,CAAC,CAAC,CACnG;IACD,OAAO,EAAE,iBAAM;IACf,WAAW,EAAE,IAAA,gBAAK,EAAC,sCAA8B,CAAC;CACrD,CAAC,CACL,CAAC;AAGW,QAAA,qCAAqC,GAAG,IAAA,oBAAS,EAC1D,4CAAyB,EACzB,IAAA,iBAAM,EAAC;IACH,WAAW,EAAE,IAAA,kBAAO,EAAC,uBAAuB,CAAC;IAE7C,6BAA6B,EAAE,IAAA,gBAAK,EAAC,gDAAwC,CAAC;CACjF,CAAC,CACL,CAAC;AAGF,SAAgB,wBAAwB,CAAC,MAAwB;IAC7D,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,WAAW,KAAK,uBAAuB,CAAC;AAClF,CAAC"}

package/lib/modules/MinecraftBlockModule.d.ts

@@ -0,0 +1,139 @@
+import { Array, Boolean, Intersect, Literal, Number, Optional, Record, Static, String, Union } from 'runtypes';
+export declare const MinecraftBlockRecord: Intersect<[Record<{
+    name: String;
+}, false>, Record<{
+    namespace: Optional<String>;
+    no_namespace_name: Optional<String>;
+    standardized_name: Optional<String>;
+}, false>, Record<{
+    has_comments: Optional<Boolean>;
+}, false>, Record<{
+    properties: Array<Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        has_comments: Optional<Boolean>;
+    }, false>, Record<{
+        property_description: Optional<Array<String, false>>;
+    }, false>]>, false>;
+    namespace: Optional<String>;
+    block_name: Optional<String>;
+    block_description: Optional<Array<String, false>>;
+    state_union: Optional<String>;
+}, false>]>;
+export type MinecraftBlock = Static<typeof MinecraftBlockRecord>;
+export declare const MinecraftBlockPropertyValueRecord: Intersect<[Record<{
+    has_comments: Optional<Boolean>;
+}, false>, Record<{
+    value: Union<[Number, String, Boolean]>;
+    value_description: Optional<Array<String, false>>;
+}, false>]>;
+export type MinecraftBlockPropertyValue = Static<typeof MinecraftBlockPropertyValueRecord>;
+export declare const MinecraftBlockPropertyRecord: Intersect<[Record<{
+    name: String;
+}, false>, Record<{
+    has_comments: Optional<Boolean>;
+}, false>, Record<{
+    type: String;
+    values: Array<Intersect<[Record<{
+        has_comments: Optional<Boolean>;
+    }, false>, Record<{
+        value: Union<[Number, String, Boolean]>;
+        value_description: Optional<Array<String, false>>;
+    }, false>]>, false>;
+    min_value: Optional<Number>;
+    max_value: Optional<Number>;
+    property_name: Optional<String>;
+    property_description: Optional<Array<String, false>>;
+    property_type: Optional<Union<[Literal<"number">, Union<[Literal<"string">, Literal<"boolean">]>]>>;
+    int_value_display_as_range: Optional<Boolean>;
+}, false>]>;
+export type MinecraftBlockProperty = Static<typeof MinecraftBlockPropertyRecord>;
+export declare const MinecraftBlockModuleRecord: Intersect<[Record<{
+    module_type: Literal<"vanilla_data">;
+    block_properties: Array<Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        has_comments: Optional<Boolean>;
+    }, false>, Record<{
+        type: String;
+        values: Array<Intersect<[Record<{
+            has_comments: Optional<Boolean>;
+        }, false>, Record<{
+            value: Union<[Number, String, Boolean]>;
+            value_description: Optional<Array<String, false>>;
+        }, false>]>, false>;
+        min_value: Optional<Number>;
+        max_value: Optional<Number>;
+        property_name: Optional<String>;
+        property_description: Optional<Array<String, false>>;
+        property_type: Optional<Union<[Literal<"number">, Union<[Literal<"string">, Literal<"boolean">]>]>>;
+        int_value_display_as_range: Optional<Boolean>;
+    }, false>]>, false>;
+    data_properties: Optional<Array<Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        has_comments: Optional<Boolean>;
+    }, false>, Record<{
+        type: String;
+        values: Array<Intersect<[Record<{
+            has_comments: Optional<Boolean>;
+        }, false>, Record<{
+            value: Union<[Number, String, Boolean]>;
+            value_description: Optional<Array<String, false>>;
+        }, false>]>, false>;
+        min_value: Optional<Number>;
+        max_value: Optional<Number>;
+        property_name: Optional<String>;
+        property_description: Optional<Array<String, false>>;
+        property_type: Optional<Union<[Literal<"number">, Union<[Literal<"string">, Literal<"boolean">]>]>>;
+        int_value_display_as_range: Optional<Boolean>;
+    }, false>]>, false>>;
+}, false>, Intersect<[Intersect<[Record<{
+    data_items: Array<Intersect<[Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        namespace: Optional<String>;
+        no_namespace_name: Optional<String>;
+        standardized_name: Optional<String>;
+    }, false>]>, Record<{
+        properties: Optional<Array<Record<{
+            name: String;
+        }, false>, false>>;
+        state_union: Optional<String>;
+        value: Optional<String>;
+    }, false>]>, false>;
+    vanilla_data_type: Optional<String>;
+    module_type: Literal<"vanilla_data">;
+    display_type: Optional<String>;
+    display_name: Optional<String>;
+    has_properties: Optional<Boolean>;
+}, false>, Record<{
+    name: String;
+    minecraft_version: String;
+    module_type: Union<[Literal<"script">, Literal<"commands">, Literal<"after_events_ordering">, Literal<"vanilla_data">]>;
+    module_name: Optional<String>;
+}, false>]>, Record<{
+    data_items: Array<Intersect<[Record<{
+        name: String;
+    }, false>, Record<{
+        namespace: Optional<String>;
+        no_namespace_name: Optional<String>;
+        standardized_name: Optional<String>;
+    }, false>, Record<{
+        has_comments: Optional<Boolean>;
+    }, false>, Record<{
+        properties: Array<Intersect<[Record<{
+            name: String;
+        }, false>, Record<{
+            has_comments: Optional<Boolean>;
+        }, false>, Record<{
+            property_description: Optional<Array<String, false>>;
+        }, false>]>, false>;
+        namespace: Optional<String>;
+        block_name: Optional<String>;
+        block_description: Optional<Array<String, false>>;
+        state_union: Optional<String>;
+    }, false>]>, false>;
+    vanilla_data_type: Optional<Literal<string>>;
+}, false>]>]>;
+export type MinecraftBlockModule = Static<typeof MinecraftBlockModuleRecord>;

package/lib/modules/MinecraftBlockModule.js

@@ -0,0 +1,37 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinecraftBlockModuleRecord = exports.MinecraftBlockPropertyRecord = exports.MinecraftBlockPropertyValueRecord = exports.MinecraftBlockRecord = void 0;
+const runtypes_1 = require("runtypes");
+const IMinecraftModule_1 = require("./IMinecraftModule");
+exports.MinecraftBlockRecord = (0, runtypes_1.Intersect)(IMinecraftModule_1.ModuleNameDataValidator, IMinecraftModule_1.StandardizedVanillaNameRecord, IMinecraftModule_1.CommonCommentFlagsValidator, (0, runtypes_1.Record)({
+    properties: (0, runtypes_1.Array)((0, runtypes_1.Intersect)(IMinecraftModule_1.ModuleNameDataValidator, IMinecraftModule_1.CommonCommentFlagsValidator, (0, runtypes_1.Record)({ property_description: (0, runtypes_1.Optional)((0, runtypes_1.Array)(runtypes_1.String)) }))),
+    // Runtime Markup
+    namespace: (0, runtypes_1.Optional)(runtypes_1.String),
+    block_name: (0, runtypes_1.Optional)(runtypes_1.String),
+    block_description: (0, runtypes_1.Optional)((0, runtypes_1.Array)(runtypes_1.String)),
+    state_union: (0, runtypes_1.Optional)(runtypes_1.String),
+}));
+exports.MinecraftBlockPropertyValueRecord = (0, runtypes_1.Intersect)(IMinecraftModule_1.CommonCommentFlagsValidator, (0, runtypes_1.Record)({
+    value: (0, runtypes_1.Union)(runtypes_1.Number, runtypes_1.String, runtypes_1.Boolean),
+    value_description: (0, runtypes_1.Optional)((0, runtypes_1.Array)(runtypes_1.String)),
+}));
+exports.MinecraftBlockPropertyRecord = (0, runtypes_1.Intersect)(IMinecraftModule_1.ModuleNameDataValidator, IMinecraftModule_1.CommonCommentFlagsValidator, (0, runtypes_1.Record)({
+    type: runtypes_1.String,
+    values: (0, runtypes_1.Array)(exports.MinecraftBlockPropertyValueRecord),
+    min_value: (0, runtypes_1.Optional)(runtypes_1.Number),
+    max_value: (0, runtypes_1.Optional)(runtypes_1.Number),
+    // Runtime Markup
+    property_name: (0, runtypes_1.Optional)(runtypes_1.String),
+    property_description: (0, runtypes_1.Optional)((0, runtypes_1.Array)(runtypes_1.String)),
+    property_type: (0, runtypes_1.Optional)((0, runtypes_1.Literal)('number').Or((0, runtypes_1.Literal)('string').Or((0, runtypes_1.Literal)('boolean')))),
+    int_value_display_as_range: (0, runtypes_1.Optional)(runtypes_1.Boolean),
+}));
+exports.MinecraftBlockModuleRecord = (0, runtypes_1.Intersect)((0, runtypes_1.Record)({
+    module_type: (0, runtypes_1.Literal)('vanilla_data'),
+    block_properties: (0, runtypes_1.Array)(exports.MinecraftBlockPropertyRecord),
+    // Runtime Markup
+    data_properties: (0, runtypes_1.Optional)((0, runtypes_1.Array)(exports.MinecraftBlockPropertyRecord)),
+}), (0, IMinecraftModule_1.getCommonVanillaDataFieldsRecord)(exports.MinecraftBlockRecord, 'block'));
+//# sourceMappingURL=MinecraftBlockModule.js.map

package/lib/modules/MinecraftBlockModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinecraftBlockModule.js","sourceRoot":"","sources":["../../src/modules/MinecraftBlockModule.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAElC,uCAA+G;AAE/G,yDAK4B;AAEf,QAAA,oBAAoB,GAAG,IAAA,oBAAS,EACzC,0CAAuB,EACvB,gDAA6B,EAC7B,8CAA2B,EAC3B,IAAA,iBAAM,EAAC;IACH,UAAU,EAAE,IAAA,gBAAK,EACb,IAAA,oBAAS,EACL,0CAAuB,EACvB,8CAA2B,EAC3B,IAAA,iBAAM,EAAC,EAAE,oBAAoB,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,iBAAM,CAAC,CAAC,EAAE,CAAC,CAC5D,CACJ;IAED,iBAAiB;IACjB,SAAS,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC3B,UAAU,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC5B,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,iBAAM,CAAC,CAAC;IAC1C,WAAW,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;CAChC,CAAC,CACL,CAAC;AAGW,QAAA,iCAAiC,GAAG,IAAA,oBAAS,EACtD,8CAA2B,EAC3B,IAAA,iBAAM,EAAC;IACH,KAAK,EAAE,IAAA,gBAAK,EAAC,iBAAM,EAAE,iBAAM,EAAE,kBAAO,CAAC;IACrC,iBAAiB,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,iBAAM,CAAC,CAAC;CAC7C,CAAC,CACL,CAAC;AAGW,QAAA,4BAA4B,GAAG,IAAA,oBAAS,EACjD,0CAAuB,EACvB,8CAA2B,EAC3B,IAAA,iBAAM,EAAC;IACH,IAAI,EAAE,iBAAM;IACZ,MAAM,EAAE,IAAA,gBAAK,EAAC,yCAAiC,CAAC;IAChD,SAAS,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC3B,SAAS,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAE3B,iBAAiB;IACjB,aAAa,EAAE,IAAA,mBAAQ,EAAC,iBAAM,CAAC;IAC/B,oBAAoB,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,iBAAM,CAAC,CAAC;IAC7C,aAAa,EAAE,IAAA,mBAAQ,EAAC,IAAA,kBAAO,EAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAA,kBAAO,EAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACvF,0BAA0B,EAAE,IAAA,mBAAQ,EAAC,kBAAO,CAAC;CAChD,CAAC,CACL,CAAC;AAGW,QAAA,0BAA0B,GAAG,IAAA,oBAAS,EAC/C,IAAA,iBAAM,EAAC;IACH,WAAW,EAAE,IAAA,kBAAO,EAAC,cAAc,CAAC;IACpC,gBAAgB,EAAE,IAAA,gBAAK,EAAC,oCAA4B,CAAC;IAErD,iBAAiB;IACjB,eAAe,EAAE,IAAA,mBAAQ,EAAC,IAAA,gBAAK,EAAC,oCAA4B,CAAC,CAAC;CACjE,CAAC,EACF,IAAA,mDAAgC,EAAC,4BAAoB,EAAE,OAAO,CAAC,CAClE,CAAC"}

package/lib/modules/MinecraftChangelogTypes.d.ts

@@ -0,0 +1,60 @@
+import * as modules from '.';
+export type ArrayChangelogEntry<T = unknown> = T & {
+    $added?: boolean;
+    $removed?: boolean;
+    version?: string;
+};
+export type ValueChangelogEntry<T = unknown> = {
+    $old: T;
+    $new: T;
+    $changed?: boolean;
+    version?: string;
+};
+export type ModuleWithChangelog<T extends modules.IMinecraftModule> = T & {
+    changelog: ArrayChangelogEntry<T>[];
+};
+export declare function isArrayChangelogEntry<T>(obj: object): obj is ArrayChangelogEntry<T>;
+export declare function isValueChangelogEntry<T>(obj: object): obj is ValueChangelogEntry<T>;
+export declare function moduleHasChangelog<T extends modules.IMinecraftModule>(module: T): module is ModuleWithChangelog<T>;
+export type IMinecraftModuleChangelogEntry = ArrayChangelogEntry<modules.IMinecraftModule>;
+export type IMinecraftModuleWithChangelog = ModuleWithChangelog<modules.IMinecraftModule>;
+export type ChangelogKey = 'changelog' | 'class_changelog' | 'interface_changelog' | 'error_changelog' | 'object_changelog' | 'function_changelog' | 'constant_changelog' | 'property_changelog' | 'enum_changelog' | 'alias_changelog';
+export type MinecraftDependencyChangelogEntry = ArrayChangelogEntry<modules.MinecraftModuleDescription>;
+export type MinecraftScriptModuleChangelogEntry = ArrayChangelogEntry<modules.MinecraftScriptModule>;
+export type MinecraftScriptModuleWithChangelog = ModuleWithChangelog<modules.MinecraftScriptModule>;
+export type MinecraftClassChangelogEntry = ArrayChangelogEntry<modules.MinecraftClass>;
+export type MinecraftClassWithChangelog = modules.MinecraftClass & {
+    class_changelog?: MinecraftClassChangelogEntry[];
+};
+export type MinecraftInterfaceChangelogEntry = ArrayChangelogEntry<modules.MinecraftInterface>;
+export type MinecraftInterfaceWithChangelog = modules.MinecraftInterface & {
+    interface_changelog?: MinecraftInterfaceChangelogEntry[];
+};
+export type MinecraftErrorChangelogEntry = ArrayChangelogEntry<modules.MinecraftError>;
+export type MinecraftErrorWithChangelog = modules.MinecraftError & {
+    error_changelog?: MinecraftErrorChangelogEntry[];
+};
+export type MinecraftObjectChangelogEntry = ArrayChangelogEntry<modules.MinecraftObject>;
+export type MinecraftObjectWithChangelog = modules.MinecraftObject & {
+    object_changelog?: MinecraftObjectChangelogEntry[];
+};
+export type MinecraftFunctionChangelogEntry = ArrayChangelogEntry<modules.MinecraftFunction>;
+export type MinecraftFunctionWithChangelog = modules.MinecraftFunction & {
+    function_changelog?: MinecraftFunctionChangelogEntry[];
+};
+export type MinecraftConstantChangelogEntry = ArrayChangelogEntry<modules.MinecraftConstant>;
+export type MinecraftConstantWithChangelog = modules.MinecraftConstant & {
+    constant_changelog?: MinecraftConstantChangelogEntry[];
+};
+export type MinecraftPropertyChangelogEntry = ArrayChangelogEntry<modules.MinecraftProperty>;
+export type MinecraftPropertyWithChangelog = modules.MinecraftProperty & {
+    property_changelog?: MinecraftPropertyChangelogEntry[];
+};
+export type MinecraftEnumChangelogEntry = ArrayChangelogEntry<modules.MinecraftEnum>;
+export type MinecraftEnumWithChangelog = modules.MinecraftEnum & {
+    enum_changelog?: MinecraftEnumChangelogEntry[];
+};
+export type MinecraftTypeAliasChangelogEntry = ArrayChangelogEntry<modules.MinecraftTypeAlias>;
+export type MinecraftTypeAliasWithChangelog = modules.MinecraftTypeAlias & {
+    alias_changelog?: MinecraftTypeAliasChangelogEntry[];
+};

package/lib/modules/MinecraftChangelogTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayChangelogEntry = isArrayChangelogEntry;
+exports.isValueChangelogEntry = isValueChangelogEntry;
+exports.moduleHasChangelog = moduleHasChangelog;
+function isArrayChangelogEntry(obj) {
+    return obj !== undefined && ('$added' in obj || '$removed' in obj);
+}
+function isValueChangelogEntry(obj) {
+    return obj !== undefined && '$old' in obj && '$new' in obj;
+}
+function moduleHasChangelog(module) {
+    return module !== undefined && 'changelog' in module;
+}
+//# sourceMappingURL=MinecraftChangelogTypes.js.map

package/lib/modules/MinecraftChangelogTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinecraftChangelogTypes.js","sourceRoot":"","sources":["../../src/modules/MinecraftChangelogTypes.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AAqBlC,sDAEC;AAED,sDAEC;AAED,gDAEC;AAVD,SAAgB,qBAAqB,CAAI,GAAW;IAChD,OAAO,GAAG,KAAK,SAAS,IAAI,CAAC,QAAQ,IAAI,GAAG,IAAI,UAAU,IAAI,GAAG,CAAC,CAAC;AACvE,CAAC;AAED,SAAgB,qBAAqB,CAAI,GAAW;IAChD,OAAO,GAAG,KAAK,SAAS,IAAI,MAAM,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC;AAC/D,CAAC;AAED,SAAgB,kBAAkB,CAAqC,MAAS;IAC5E,OAAO,MAAM,KAAK,SAAS,IAAI,WAAW,IAAI,MAAM,CAAC;AACzD,CAAC"}