jsii-pacmak 1.65.0 → 1.67.0

package/lib/targets/go/types/class.js

@@ -1,9 +1,22 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _GoClass_parameterValidators, _GoClassConstructor_validator;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticMethod = exports.ClassMethod = exports.GoClassConstructor = exports.GoClass = void 0;
 const naming_util_1 = require("../../../naming-util");
 const comparators = require("../comparators");
 const runtime_1 = require("../runtime");
+const runtime_type_checking_1 = require("../runtime/runtime-type-checking");
 const util_1 = require("../util");
 const go_type_1 = require("./go-type");
 const go_type_reference_1 = require("./go-type-reference");
@@ -14,6 +27,7 @@ const type_member_1 = require("./type-member");
 class GoClass extends go_type_1.GoType {
     constructor(pkg, type) {
         super(pkg, type);
+        _GoClass_parameterValidators.set(this, void 0);
         const methods = new Array();
         const staticMethods = new Array();
         for (const method of type.allMethods) {
@@ -44,6 +58,20 @@ class GoClass extends go_type_1.GoType {
             this.initializer = new GoClassConstructor(this, type.initializer);
         }
     }
+    get parameterValidators() {
+        if (__classPrivateFieldGet(this, _GoClass_parameterValidators, "f") === undefined) {
+            __classPrivateFieldSet(this, _GoClass_parameterValidators, [
+                ...this.methods.map((m) => m.validator).filter((v) => v != null),
+                ...this.staticMethods.map((m) => m.validator).filter((v) => v != null),
+                ...this.properties.map((m) => m.validator).filter((v) => v != null),
+                ...this.staticProperties
+                    .map((m) => m.validator)
+                    .filter((v) => v != null),
+                ...(this.initializer?.validator ? [this.initializer.validator] : []),
+            ], "f");
+        }
+        return __classPrivateFieldGet(this, _GoClass_parameterValidators, "f");
+    }
     get extends() {
         // Cannot compute in constructor, as dependencies may not have finished
         // resolving just yet.
@@ -80,13 +108,14 @@ class GoClass extends go_type_1.GoType {
             method.emit(context);
         }
         for (const prop of this.staticProperties) {
-            this.emitStaticProperty(context, prop);
+            prop.emitGetterProxy(context);
+            prop.emitSetterProxy(context);
         }
         for (const method of this.methods) {
             method.emit(context);
         }
     }
-    emitRegistration(code) {
+    emitRegistration({ code }) {
         code.open(`${runtime_1.JSII_RT_ALIAS}.RegisterClass(`);
         code.line(`"${this.fqn}",`);
         code.line(`reflect.TypeOf((*${this.name})(nil)).Elem(),`);
@@ -122,10 +151,11 @@ class GoClass extends go_type_1.GoType {
     }
     get specialDependencies() {
         return {
-            runtime: this.initializer != null || this.members.length > 0,
+            fmt: false,
             init: this.initializer != null ||
                 this.members.some((m) => m.specialDependencies.init),
             internal: this.baseTypes.some((base) => this.pkg.isExternalType(base)),
+            runtime: this.initializer != null || this.members.length > 0,
             time: !!this.initializer?.specialDependencies.time ||
                 this.members.some((m) => m.specialDependencies.time),
         };
@@ -175,23 +205,6 @@ class GoClass extends go_type_1.GoType {
         code.closeBlock();
         code.line();
     }
-    emitStaticProperty({ code }, prop) {
-        const getCaller = new runtime_1.StaticGetProperty(prop);
-        const propertyName = (0, naming_util_1.jsiiToPascalCase)(prop.name);
-        const name = `${this.name}_${propertyName}`;
-        code.openBlock(`func ${name}() ${prop.returnType}`);
-        getCaller.emit(code);
-        code.closeBlock();
-        code.line();
-        if (!prop.immutable) {
-            const setCaller = new runtime_1.StaticSetProperty(prop);
-            const name = `${this.name}_Set${propertyName}`;
-            code.openBlock(`func ${name}(val ${prop.returnType})`);
-            setCaller.emit(code);
-            code.closeBlock();
-            code.line();
-        }
-    }
     // emits the implementation of the setters for the struct
     emitSetters(context) {
         for (const property of this.properties) {
@@ -214,18 +227,27 @@ class GoClass extends go_type_1.GoType {
     }
 }
 exports.GoClass = GoClass;
+_GoClass_parameterValidators = new WeakMap();
 class GoClassConstructor extends type_member_1.GoMethod {
     constructor(parent, type) {
         super(parent, type);
         this.parent = parent;
         this.type = type;
+        _GoClassConstructor_validator.set(this, null);
         this.constructorRuntimeCall = new runtime_1.ClassConstructor(this);
     }
+    get validator() {
+        if (__classPrivateFieldGet(this, _GoClassConstructor_validator, "f") === null) {
+            __classPrivateFieldSet(this, _GoClassConstructor_validator, runtime_type_checking_1.ParameterValidator.forConstructor(this), "f");
+        }
+        return __classPrivateFieldGet(this, _GoClassConstructor_validator, "f");
+    }
     get specialDependencies() {
         return {
-            runtime: true,
+            fmt: false,
             init: true,
             internal: false,
+            runtime: true,
             time: this.parameters.some((p) => p.reference.specialDependencies.time),
         };
     }
@@ -239,14 +261,15 @@ class GoClassConstructor extends type_member_1.GoMethod {
             this.emitOverride(context);
         }
     }
-    emitNew({ code, documenter }) {
+    emitNew(context) {
+        const { code, documenter } = context;
         const constr = `New${this.parent.name}`;
         const paramString = this.parameters.length === 0
             ? ''
             : this.parameters.map((p) => p.toString()).join(', ');
         documenter.emit(this.type.docs, this.apiLocation);
         code.openBlock(`func ${constr}(${paramString}) ${this.parent.name}`);
-        this.constructorRuntimeCall.emit(code);
+        this.constructorRuntimeCall.emit(context);
         code.closeBlock();
         code.line();
     }
@@ -263,6 +286,7 @@ class GoClassConstructor extends type_member_1.GoMethod {
     }
 }
 exports.GoClassConstructor = GoClassConstructor;
+_GoClassConstructor_validator = new WeakMap();
 class ClassMethod extends type_member_1.GoMethod {
     constructor(parent, method) {
         super(parent, method);
@@ -271,11 +295,12 @@ class ClassMethod extends type_member_1.GoMethod {
         this.runtimeCall = new runtime_1.MethodCall(this);
     }
     /* emit generates method implementation on the class */
-    emit({ code }) {
+    emit(context) {
         const name = this.name;
         const returnTypeString = this.reference?.void ? '' : ` ${this.returnType}`;
+        const { code } = context;
         code.openBlock(`func (${this.instanceArg} *${this.parent.proxyName}) ${name}(${this.paramString()})${returnTypeString}`);
-        this.runtimeCall.emit(code);
+        this.runtimeCall.emit(context);
         code.closeBlock();
         code.line();
     }
@@ -288,11 +313,15 @@ class ClassMethod extends type_member_1.GoMethod {
     get instanceArg() {
         return this.parent.name.substring(0, 1).toLowerCase();
     }
+    get static() {
+        return !!this.method.spec.static;
+    }
     get specialDependencies() {
         return {
-            runtime: true,
+            fmt: false,
             init: this.method.static,
             internal: false,
+            runtime: true,
             time: !!this.parameters.some((p) => p.reference.specialDependencies.time) ||
                 !!this.reference?.specialDependencies.time,
         };
@@ -304,13 +333,14 @@ class StaticMethod extends ClassMethod {
         super(parent, method);
         this.parent = parent;
         this.method = method;
+        this.name = `${this.parent.name}_${(0, naming_util_1.jsiiToPascalCase)(method.name)}`;
     }
-    emit({ code, documenter }) {
-        const name = `${this.parent.name}_${this.name}`;
+    emit(context) {
         const returnTypeString = this.reference?.void ? '' : ` ${this.returnType}`;
+        const { code, documenter } = context;
         documenter.emit(this.method.docs, this.apiLocation);
-        code.openBlock(`func ${name}(${this.paramString()})${returnTypeString}`);
-        this.runtimeCall.emit(code);
+        code.openBlock(`func ${this.name}(${this.paramString()})${returnTypeString}`);
+        this.runtimeCall.emit(context);
         code.closeBlock();
         code.line();
     }

package/lib/targets/go/types/enum.d.ts

@@ -1,4 +1,3 @@
-import { CodeMaker } from 'codemaker';
 import { EnumType } from 'jsii-reflect';
 import { SpecialDependencies } from '../dependencies';
 import { EmitContext } from '../emit-context';
@@ -7,8 +6,9 @@ import { GoType } from './go-type';
 export declare class Enum extends GoType<EnumType> {
     private readonly members;
     constructor(pkg: Package, type: EnumType);
+    get parameterValidators(): never[];
     emit(context: EmitContext): void;
-    emitRegistration(code: CodeMaker): void;
+    emitRegistration({ code }: EmitContext): void;
     get dependencies(): Package[];
     get specialDependencies(): SpecialDependencies;
 }

package/lib/targets/go/types/enum.js

@@ -8,6 +8,9 @@ class Enum extends go_type_1.GoType {
         super(pkg, type);
         this.members = type.members.map((mem) => new GoEnumMember(this, mem));
     }
+    get parameterValidators() {
+        return [];
+    }
     emit(context) {
         this.emitDocs(context);
         const { code } = context;
@@ -23,7 +26,7 @@ class Enum extends go_type_1.GoType {
         code.close(`)`);
         code.line();
     }
-    emitRegistration(code) {
+    emitRegistration({ code }) {
         code.open(`${runtime_1.JSII_RT_ALIAS}.RegisterEnum(`);
         code.line(`"${this.fqn}",`);
         code.line(`reflect.TypeOf((*${this.name})(nil)).Elem(),`);
@@ -39,9 +42,10 @@ class Enum extends go_type_1.GoType {
     }
     get specialDependencies() {
         return {
-            runtime: false,
+            fmt: false,
             init: false,
             internal: false,
+            runtime: false,
             time: false,
         };
     }

package/lib/targets/go/types/go-type-reference.d.ts

@@ -27,8 +27,11 @@ declare type TypeMap = {
 export declare class GoTypeRef {
     readonly root: Package;
     readonly reference: TypeReference;
+    private readonly options;
     private _typeMap?;
-    constructor(root: Package, reference: TypeReference);
+    constructor(root: Package, reference: TypeReference, options?: {
+        readonly opaqueUnionTypes: boolean;
+    });
     get type(): GoType | undefined;
     get specialDependencies(): SpecialDependencies;
     get primitiveType(): string | undefined;
@@ -41,6 +44,8 @@ export declare class GoTypeRef {
      * The go `import`s required in order to be able to use this type in code.
      */
     get dependencies(): readonly Package[];
+    get unionOfTypes(): readonly GoTypeRef[] | undefined;
+    get withTransparentUnions(): GoTypeRef;
     scopedName(scope: Package): string;
     scopedReference(scope: Package): string;
     private buildTypeMap;

package/lib/targets/go/types/go-type-reference.js

@@ -29,9 +29,12 @@ class PrimitiveMapper {
  * Accepts a JSII TypeReference and Go Package and can resolve the GoType within the module tree.
  */
 class GoTypeRef {
-    constructor(root, reference) {
+    constructor(root, reference, options = {
+        opaqueUnionTypes: true,
+    }) {
         this.root = root;
         this.reference = reference;
+        this.options = options;
     }
     get type() {
         if (this.reference.fqn) {
@@ -41,27 +44,25 @@ class GoTypeRef {
     }
     get specialDependencies() {
         return {
-            runtime: false,
+            fmt: false,
             init: false,
             internal: false,
-            time: containsDate(this.reference),
+            runtime: false,
+            time: containsDate(this.reference, this.options.opaqueUnionTypes),
         };
-        function containsDate(ref) {
+        function containsDate(ref, opaqueUnionType) {
             if (ref.primitive === 'date') {
                 return true;
             }
             if (ref.arrayOfType) {
-                return containsDate(ref.arrayOfType);
+                return containsDate(ref.arrayOfType, opaqueUnionType);
             }
             if (ref.mapOfType) {
-                return containsDate(ref.mapOfType);
+                return containsDate(ref.mapOfType, opaqueUnionType);
+            }
+            if (!opaqueUnionType && ref.unionOfTypes) {
+                return ref.unionOfTypes.some((item) => containsDate(item, opaqueUnionType));
             }
-            // NOTE: UNION gets represented as interface{} so we don't need to import
-            // individual types here...
-            //
-            // if (ref.unionOfTypes) {
-            //   return ref.unionOfTypes.some(containsDate);
-            // }
             return false;
         }
     }
@@ -106,12 +107,11 @@ class GoTypeRef {
                 ret.push(...this.typeMap.value.dependencies);
                 break;
             case 'union':
-                // Unions ultimately result in `interface{}` being rendered, so no import is needed. We
-                // hence ignore them entirely here for now. In the future, we may want to inject specific
-                // runtime type checks around use of unions, which may result in imports being useful.
-                // for (const t of this.typeMap.value) {
-                //   ret.push(...t.dependencies);
-                // }
+                if (!this.options.opaqueUnionTypes) {
+                    for (const t of this.typeMap.value) {
+                        ret.push(...t.dependencies);
+                    }
+                }
                 break;
             case 'void':
             case 'primitive':
@@ -119,6 +119,22 @@ class GoTypeRef {
         }
         return ret;
     }
+    get unionOfTypes() {
+        const typeMap = this.typeMap;
+        if (typeMap.type !== 'union') {
+            return undefined;
+        }
+        return typeMap.value;
+    }
+    get withTransparentUnions() {
+        if (!this.options.opaqueUnionTypes) {
+            return this;
+        }
+        return new GoTypeRef(this.root, this.reference, {
+            ...this.options,
+            opaqueUnionTypes: false,
+        });
+    }
     /*
      * Return the name of a type for reference from the `Package` passed in
      */
@@ -135,19 +151,19 @@ class GoTypeRef {
         else if (ref.reference.arrayOfType) {
             return {
                 type: 'array',
-                value: new GoTypeRef(this.root, ref.reference.arrayOfType),
+                value: new GoTypeRef(this.root, ref.reference.arrayOfType, this.options),
             };
         }
         else if (ref.reference.mapOfType) {
             return {
                 type: 'map',
-                value: new GoTypeRef(this.root, ref.reference.mapOfType),
+                value: new GoTypeRef(this.root, ref.reference.mapOfType, this.options),
             };
         }
         else if (ref.reference.unionOfTypes) {
             return {
                 type: 'union',
-                value: ref.reference.unionOfTypes.map((typeRef) => new GoTypeRef(this.root, typeRef)),
+                value: ref.reference.unionOfTypes.map((typeRef) => new GoTypeRef(this.root, typeRef, this.options)),
             };
         }
         else if (ref.reference.void) {

package/lib/targets/go/types/go-type.d.ts

@@ -4,6 +4,7 @@ import { ApiLocation } from 'jsii-rosetta';
 import { SpecialDependencies } from '../dependencies';
 import { EmitContext } from '../emit-context';
 import { Package } from '../package';
+import { ParameterValidator, StructValidator } from '../runtime/runtime-type-checking';
 import { GoClass } from './class';
 import { GoInterface } from './interface';
 export declare abstract class GoType<T extends Type = Type> {
@@ -14,8 +15,10 @@ export declare abstract class GoType<T extends Type = Type> {
     readonly proxyName: string;
     protected readonly apiLocation: ApiLocation;
     constructor(pkg: Package, type: T);
+    get structValidator(): StructValidator | undefined;
+    abstract get parameterValidators(): readonly ParameterValidator[];
     abstract emit(context: EmitContext): void;
-    abstract emitRegistration(code: CodeMaker): void;
+    abstract emitRegistration(context: EmitContext): void;
     abstract get dependencies(): Package[];
     abstract get specialDependencies(): SpecialDependencies;
     get namespace(): string;

package/lib/targets/go/types/go-type.js

@@ -17,6 +17,9 @@ class GoType {
         this.fqn = type.fqn;
         this.apiLocation = { api: 'type', fqn: this.fqn };
     }
+    get structValidator() {
+        return undefined;
+    }
     get namespace() {
         return this.pkg.packageName;
     }

package/lib/targets/go/types/interface.d.ts

@@ -1,19 +1,21 @@
-import { CodeMaker } from 'codemaker';
 import { InterfaceType, Method, Property } from 'jsii-reflect';
 import { SpecialDependencies } from '../dependencies';
 import { EmitContext } from '../emit-context';
 import { Package } from '../package';
 import { MethodCall } from '../runtime';
+import { ParameterValidator } from '../runtime/runtime-type-checking';
 import { GoType } from './go-type';
 import { GoMethod, GoProperty } from './type-member';
 export declare class GoInterface extends GoType<InterfaceType> {
+    #private;
     readonly methods: InterfaceMethod[];
     readonly reimplementedMethods: readonly InterfaceMethod[];
     readonly properties: InterfaceProperty[];
     readonly reimplementedProperties: readonly InterfaceProperty[];
     constructor(pkg: Package, type: InterfaceType);
+    get parameterValidators(): readonly ParameterValidator[];
     emit(context: EmitContext): void;
-    emitRegistration(code: CodeMaker): void;
+    emitRegistration({ code }: EmitContext): void;
     get specialDependencies(): SpecialDependencies;
     get extends(): GoInterface[];
     get extendsDependencies(): Package[];
@@ -32,7 +34,7 @@ declare class InterfaceMethod extends GoMethod {
     readonly runtimeCall: MethodCall;
     constructor(parent: GoInterface, method: Method);
     emitDecl({ code, documenter }: EmitContext): void;
-    emit({ code }: EmitContext): void;
+    emit(context: EmitContext): void;
     get specialDependencies(): SpecialDependencies;
     private get returnTypeString();
 }

package/lib/targets/go/types/interface.js

@@ -1,7 +1,20 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _GoInterface_parameterValidators;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoInterface = void 0;
 const comparators = require("../comparators");
+const dependencies_1 = require("../dependencies");
 const runtime_1 = require("../runtime");
 const util_1 = require("../util");
 const go_type_1 = require("./go-type");
@@ -10,6 +23,7 @@ const type_member_1 = require("./type-member");
 class GoInterface extends go_type_1.GoType {
     constructor(pkg, type) {
         super(pkg, type);
+        _GoInterface_parameterValidators.set(this, void 0);
         this.methods = type.ownMethods
             .map((method) => new InterfaceMethod(this, method))
             .sort(comparators.byName);
@@ -39,6 +53,21 @@ class GoInterface extends go_type_1.GoType {
             this.reimplementedProperties = [];
         }
     }
+    get parameterValidators() {
+        if (__classPrivateFieldGet(this, _GoInterface_parameterValidators, "f") == null) {
+            __classPrivateFieldSet(this, _GoInterface_parameterValidators, [
+                ...this.methods.map((m) => m.validator).filter((v) => v != null),
+                ...this.reimplementedMethods
+                    .map((m) => m.validator)
+                    .filter((v) => v != null),
+                ...this.properties.map((p) => p.validator).filter((v) => v != null),
+                ...this.reimplementedProperties
+                    .map((p) => p.validator)
+                    .filter((v) => v != null),
+            ], "f");
+        }
+        return __classPrivateFieldGet(this, _GoInterface_parameterValidators, "f");
+    }
     emit(context) {
         this.emitDocs(context);
         const { code } = context;
@@ -87,7 +116,7 @@ class GoInterface extends go_type_1.GoType {
             }
         }
     }
-    emitRegistration(code) {
+    emitRegistration({ code }) {
         code.open(`${runtime_1.JSII_RT_ALIAS}.RegisterInterface(`);
         code.line(`"${this.fqn}",`);
         code.line(`reflect.TypeOf((*${this.name})(nil)).Elem(),`);
@@ -113,22 +142,13 @@ class GoInterface extends go_type_1.GoType {
         code.close(')');
     }
     get specialDependencies() {
-        return [
-            ...this.properties.map((p) => p.specialDependencies),
-            ...this.reimplementedProperties.map((p) => p.specialDependencies),
-            ...this.methods.map((m) => m.specialDependencies),
-            ...this.reimplementedMethods.map((m) => m.specialDependencies),
-        ].reduce((acc, elt) => ({
-            runtime: acc.runtime || elt.runtime,
-            init: acc.init || elt.init,
-            internal: acc.internal,
-            time: acc.time || elt.time,
-        }), {
-            runtime: false,
+        return (0, dependencies_1.reduceSpecialDependencies)({
+            fmt: false,
             init: false,
             internal: this.extends.some((base) => this.pkg.isExternalType(base)),
+            runtime: false,
             time: false,
-        });
+        }, ...this.properties.map((p) => p.specialDependencies), ...this.reimplementedProperties.map((p) => p.specialDependencies), ...this.methods.map((m) => m.specialDependencies), ...this.reimplementedMethods.map((m) => m.specialDependencies));
     }
     get extends() {
         return this.type.interfaces
@@ -158,6 +178,7 @@ class GoInterface extends go_type_1.GoType {
     }
 }
 exports.GoInterface = GoInterface;
+_GoInterface_parameterValidators = new WeakMap();
 class InterfaceProperty extends type_member_1.GoProperty {
     constructor(parent, property) {
         super(parent, property);
@@ -190,18 +211,20 @@ class InterfaceMethod extends type_member_1.GoMethod {
         documenter.emit(this.method.docs, this.apiLocation);
         code.line(`${this.name}(${this.paramString()})${this.returnTypeString}`);
     }
-    emit({ code }) {
+    emit(context) {
         const name = this.name;
+        const { code } = context;
         code.openBlock(`func (${this.instanceArg} *${this.parent.proxyName}) ${name}(${this.paramString()})${this.returnTypeString}`);
-        this.runtimeCall.emit(code);
+        this.runtimeCall.emit(context);
         code.closeBlock();
         code.line();
     }
     get specialDependencies() {
         return {
-            runtime: true,
+            fmt: false,
             init: false,
             internal: false,
+            runtime: true,
             time: this.parameters.some((p) => p.reference.specialDependencies.time) ||
                 !!this.reference?.specialDependencies.time,
         };

package/lib/targets/go/types/struct.d.ts

@@ -1,15 +1,19 @@
-import { CodeMaker } from 'codemaker';
 import { InterfaceType } from 'jsii-reflect';
 import { SpecialDependencies } from '../dependencies';
 import { EmitContext } from '../emit-context';
 import { Package } from '../package';
+import { ParameterValidator, StructValidator } from '../runtime/runtime-type-checking';
 import { GoType } from './go-type';
+import { GoProperty } from './type-member';
 export declare class Struct extends GoType<InterfaceType> {
-    private readonly properties;
+    #private;
+    readonly properties: readonly GoProperty[];
     constructor(parent: Package, type: InterfaceType);
+    get parameterValidators(): readonly ParameterValidator[];
+    get structValidator(): StructValidator | undefined;
     get dependencies(): Package[];
     get specialDependencies(): SpecialDependencies;
     emit(context: EmitContext): void;
-    emitRegistration(code: CodeMaker): void;
+    emitRegistration({ code, runtimeTypeChecking }: EmitContext): void;
 }
 //# sourceMappingURL=struct.d.ts.map