diff --git a/packages/@jsii/go-runtime-test/project/compliance_test.go b/packages/@jsii/go-runtime-test/project/compliance_test.go index 6ed796787d..20e0142922 100644 --- a/packages/@jsii/go-runtime-test/project/compliance_test.go +++ b/packages/@jsii/go-runtime-test/project/compliance_test.go @@ -62,7 +62,7 @@ func (suite *ComplianceSuite) TestPrimitiveTypes() { func (suite *ComplianceSuite) TestUseNestedStruct() { suite.FailTest("Nested types are not namespaced", "https://github.com/aws/jsii/pull/2650") - scopejsiicalcbase.StaticConsumer_Consume(submodule.NestedStruct{ + scopejsiicalcbase.StaticConsumer_Consume(submodule.NestingClass_NestedStruct{ Name: "Bond, James Bond", }) } @@ -273,10 +273,10 @@ func (suite* ComplianceSuite) TestGetAndSetEnumValues() { calc := calc.NewCalculator(calc.CalculatorProps{}) calc.Add(9) calc.Pow(3) - assert.Equal(composition.CompositionStringStyle_NORMAL, calc.StringStyle()) + assert.Equal(composition.CompositeOperation_CompositionStringStyle_NORMAL, calc.StringStyle()) - calc.SetStringStyle(composition.CompositionStringStyle_DECORATED) - assert.Equal(composition.CompositionStringStyle_DECORATED, calc.StringStyle()) + calc.SetStringStyle(composition.CompositeOperation_CompositionStringStyle_DECORATED) + assert.Equal(composition.CompositeOperation_CompositionStringStyle_DECORATED, calc.StringStyle()) assert.Equal("<<[[{{(((1 * (0 + 9)) * (0 + 9)) * (0 + 9))}}]]>>", calc.ToString()) } diff --git a/packages/jsii-pacmak/.eslintrc.yaml b/packages/jsii-pacmak/.eslintrc.yaml index 8ca30cb87b..0cef14cbfe 100644 --- a/packages/jsii-pacmak/.eslintrc.yaml +++ b/packages/jsii-pacmak/.eslintrc.yaml @@ -1,2 +1,5 @@ --- extends: ../../eslint-config.yaml + +ignorePatterns: + - test/generated-code/examples/** diff --git a/packages/jsii-pacmak/lib/targets/go/types/go-type.ts b/packages/jsii-pacmak/lib/targets/go/types/go-type.ts index c90df336f0..c29896eb4e 100644 --- a/packages/jsii-pacmak/lib/targets/go/types/go-type.ts +++ b/packages/jsii-pacmak/lib/targets/go/types/go-type.ts @@ -1,4 +1,4 @@ -import { CodeMaker, toCamelCase, toPascalCase } from 'codemaker'; +import { CodeMaker, toPascalCase } from 'codemaker'; import { Type } from 'jsii-reflect'; import { EmitContext } from '../emit-context'; @@ -14,9 +14,20 @@ export abstract class GoType { public constructor(public pkg: Package, public type: Type) { this.name = toPascalCase(type.name); - // add "_jsiiProxy" postfix to private struct name to avoid keyword - // conflicts such as "default". see https://github.com/aws/jsii/issues/2637 - this.proxyName = `${toCamelCase(type.name)}_jsiiProxy`; + + // Prefix with the nesting parent name(s), using an _ delimiter. + for ( + let parent = type.nestingParent; + parent != null; + parent = parent.nestingParent + ) { + this.name = `${toPascalCase(parent.name)}_${this.name}`; + } + + // Add "jsiiProxy_" prefix to private struct name to avoid keyword conflicts + // such as "default". See https://github.com/aws/jsii/issues/2637 + this.proxyName = `jsiiProxy_${this.name}`; + this.fqn = type.fqn; } diff --git a/packages/jsii-pacmak/package.json b/packages/jsii-pacmak/package.json index 375d8de456..da7d39959f 100644 --- a/packages/jsii-pacmak/package.json +++ b/packages/jsii-pacmak/package.json @@ -64,6 +64,7 @@ "@types/yargs": "^16.0.0", "eslint": "^7.21.0", "jest": "^26.6.3", + "jsii": "^0.0.0", "jsii-build-tools": "^0.0.0", "jsii-calc": "^3.20.120", "prettier": "^2.2.1", diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/examples.test.ts.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/examples.test.ts.snap new file mode 100644 index 0000000000..4f11a475ed --- /dev/null +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/examples.test.ts.snap @@ -0,0 +1,1214 @@ +// Jest Snapshot v1, https://goo.gl/fbAQLP + +exports[`nested-types.ts: / 1`] = ` + + ┣━ 📁 dotnet + ┃ ┗━ 📁 Example.Test.Demo + ┃ ┣━ 📄 AssemblyInfo.cs + ┃ ┣━ 📁 Example + ┃ ┃ ┗━ 📁 Test + ┃ ┃ ┗━ 📁 Demo + ┃ ┃ ┣━ 📁 Internal + ┃ ┃ ┃ ┗━ 📁 DependencyResolution + ┃ ┃ ┃ ┗━ 📄 Anchor.cs + ┃ ┃ ┣━ 📄 Namespace1.cs + ┃ ┃ ┗━ 📄 Namespace2.cs + ┃ ┗━ 📄 Example.Test.Demo.csproj + ┣━ 📁 go + ┃ ┗━ 📁 testpkg + ┃ ┣━ 📄 go.mod + ┃ ┣━ 📁 jsii + ┃ ┃ ┗━ 📄 jsii.go + ┃ ┣━ 📄 testpkg.go + ┃ ┗━ 📄 testpkg.init.go + ┣━ 📁 java + ┃ ┣━ 📄 pom.xml + ┃ ┗━ 📁 src + ┃ ┗━ 📁 main + ┃ ┣━ 📁 java + ┃ ┃ ┗━ 📁 example + ┃ ┃ ┗━ 📁 test + ┃ ┃ ┗━ 📁 demo + ┃ ┃ ┣━ 📄 $Module.java + ┃ ┃ ┣━ 📄 Namespace1.java + ┃ ┃ ┗━ 📄 Namespace2.java + ┃ ┗━ 📁 resources + ┃ ┗━ 📁 example + ┃ ┗━ 📁 test + ┃ ┗━ 📁 demo + ┃ ┗━ 📄 $Module.txt + ┗━ 📁 python + ┣━ 📄 pyproject.toml + ┣━ 📄 setup.py + ┗━ 📁 src + ┗━ 📁 example_test_demo + ┣━ 📄 __init__.py + ┣━ 📁 _jsii + ┃ ┗━ 📄 __init__.py + ┗━ 📄 py.typed +`; + +exports[`nested-types.ts: /dotnet/Example.Test.Demo/AssemblyInfo.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +[assembly: JsiiAssembly("testpkg", "0.0.1", "testpkg-0.0.1.tgz")] + +`; + +exports[`nested-types.ts: /dotnet/Example.Test.Demo/Example.Test.Demo.csproj 1`] = ` + + + + testpkg + Example.Test.Demo + Apache-2.0 + 0.0.1 + + John Doe + en-US + https://github.com/aws/jsii.git + https://github.com/aws/jsii.git + git + + true + true + true + true + enable + snupkg + netcoreapp3.1 + + + + + + + + + + 0612,0618 + + 0108,0109 + + + + +`; + +exports[`nested-types.ts: /dotnet/Example.Test.Demo/Example/Test/Demo/Internal/DependencyResolution/Anchor.cs 1`] = ` +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Example.Test.Demo.Internal.DependencyResolution +{ + public sealed class Anchor + { + public Anchor() + { + } + } +} + +`; + +exports[`nested-types.ts: /dotnet/Example.Test.Demo/Example/Test/Demo/Namespace1.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Example.Test.Demo +{ + [JsiiClass(nativeType: typeof(Example.Test.Demo.Namespace1), fullyQualifiedName: "testpkg.Namespace1")] + public class Namespace1 : DeputyBase + { + public Namespace1(): base(new DeputyProps(System.Array.Empty())) + { + } + + /// Used by jsii to construct an instance of this class from a Javascript-owned object reference + /// The Javascript-owned object reference + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Namespace1(ByRefValue reference): base(reference) + { + } + + /// Used by jsii to construct an instance of this class from DeputyProps + /// The deputy props + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Namespace1(DeputyProps props): base(props) + { + } + + [JsiiMethod(name: "foo")] + public virtual void Foo() + { + InvokeInstanceVoidMethod(new System.Type[]{}, new object[]{}); + } + [JsiiInterface(nativeType: typeof(IFoo), fullyQualifiedName: "testpkg.Namespace1.Foo")] + public interface IFoo + { + [JsiiProperty(name: "bar", typeJson: "{\\"primitive\\":\\"string\\"}")] + string Bar + { + get; + } + + [JsiiTypeProxy(nativeType: typeof(IFoo), fullyQualifiedName: "testpkg.Namespace1.Foo")] + internal sealed class _Proxy : DeputyBase, Example.Test.Demo.Namespace1.IFoo + { + private _Proxy(ByRefValue reference): base(reference) + { + } + + [JsiiProperty(name: "bar", typeJson: "{\\"primitive\\":\\"string\\"}")] + public string Bar + { + get => GetInstanceProperty()!; + } + } + } + #pragma warning disable CS8618 + + [JsiiByValue(fqn: "testpkg.Namespace1.Foo")] + public class Foo : Example.Test.Demo.Namespace1.IFoo + { + [JsiiProperty(name: "bar", typeJson: "{\\"primitive\\":\\"string\\"}", isOverride: true)] + public string Bar + { + get; + set; + } + } + [JsiiInterface(nativeType: typeof(IBar), fullyQualifiedName: "testpkg.Namespace1.IBar")] + public interface IBar + { + [JsiiProperty(name: "bar", typeJson: "{\\"primitive\\":\\"string\\"}")] + string Bar + { + get; + } + [JsiiMethod(name: "method")] + void Method(); + + [JsiiTypeProxy(nativeType: typeof(IBar), fullyQualifiedName: "testpkg.Namespace1.IBar")] + internal sealed class _Proxy : DeputyBase, Example.Test.Demo.Namespace1.IBar + { + private _Proxy(ByRefValue reference): base(reference) + { + } + + [JsiiProperty(name: "bar", typeJson: "{\\"primitive\\":\\"string\\"}")] + public string Bar + { + get => GetInstanceProperty()!; + } + + [JsiiMethod(name: "method")] + public void Method() + { + InvokeInstanceVoidMethod(new System.Type[]{}, new object[]{}); + } + } + } + } +} + +`; + +exports[`nested-types.ts: /dotnet/Example.Test.Demo/Example/Test/Demo/Namespace2.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Example.Test.Demo +{ + [JsiiClass(nativeType: typeof(Example.Test.Demo.Namespace2), fullyQualifiedName: "testpkg.Namespace2")] + public class Namespace2 : DeputyBase + { + public Namespace2(): base(new DeputyProps(System.Array.Empty())) + { + } + + /// Used by jsii to construct an instance of this class from a Javascript-owned object reference + /// The Javascript-owned object reference + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Namespace2(ByRefValue reference): base(reference) + { + } + + /// Used by jsii to construct an instance of this class from DeputyProps + /// The deputy props + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Namespace2(DeputyProps props): base(props) + { + } + + [JsiiMethod(name: "foo")] + public virtual void Foo() + { + InvokeInstanceVoidMethod(new System.Type[]{}, new object[]{}); + } + + [JsiiEnum(nativeType: typeof(Foo), fullyQualifiedName: "testpkg.Namespace2.Foo")] + public enum Foo + { + [JsiiEnumMember(name: "BAR")] + BAR, + [JsiiEnumMember(name: "BAZ")] + BAZ + [JsiiClass(nativeType: typeof(Example.Test.Demo.Namespace2.Foo.Final), fullyQualifiedName: "testpkg.Namespace2.Foo.Final")] + public class Final : DeputyBase + { + public Final(): base(new DeputyProps(System.Array.Empty())) + { + } + + /// Used by jsii to construct an instance of this class from a Javascript-owned object reference + /// The Javascript-owned object reference + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Final(ByRefValue reference): base(reference) + { + } + + /// Used by jsii to construct an instance of this class from DeputyProps + /// The deputy props + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Final(DeputyProps props): base(props) + { + } + + [JsiiProperty(name: "done", typeJson: "{\\"primitive\\":\\"boolean\\"}")] + public virtual bool Done + { + get => GetInstanceProperty()!; + } + } + } + } +} + +`; + +exports[`nested-types.ts: /go/testpkg/go.mod 1`] = ` +module example.test/demo/testpkg + +go 1.16 + +require ( + github.com/aws/jsii-runtime-go v0.0.0 +) + +`; + +exports[`nested-types.ts: /go/testpkg/jsii/jsii.go 1`] = ` +// Package jsii contains the functionaility needed for jsii packages to +// initialize their dependencies and themselves. Users should never need to use this package +// directly. If you find you need to - please report a bug at +// https://github.com/aws/jsii/issues/new/choose +package jsii + +import ( + _ "embed" + + _jsii_ "github.com/aws/jsii-runtime-go" +) + +//go:embed testpkg-0.0.1.tgz +var tarball []byte + +// Initialize loads the necessary packages in the @jsii/kernel to support the enclosing module. +// The implementation is idempotent (and hence safe to be called over and over). +func Initialize() { + // Load this library into the kernel + _jsii_.Load("testpkg", "0.0.1", tarball) +} + +`; + +exports[`nested-types.ts: /go/testpkg/testpkg.go 1`] = ` +// testpkg +package testpkg + +import ( + _init_ "example.test/demo/testpkg/jsii" + _jsii_ "github.com/aws/jsii-runtime-go" +) + +type Namespace1 interface { + Foo() +} + +// The jsii proxy struct for Namespace1 +type jsiiProxy_Namespace1 struct { + _ byte // padding +} + +func NewNamespace1() Namespace1 { + _init_.Initialize() + + j := jsiiProxy_Namespace1{} + + _jsii_.Create( + "testpkg.Namespace1", + nil /* no parameters */, + []_jsii_.FQN{}, + nil, // no overrides + &j, + ) + + return &j +} + +func (n *jsiiProxy_Namespace1) Foo() { + _jsii_.InvokeVoid( + n, + "foo", + nil /* no parameters */, + ) +} + +type Namespace1_Foo struct { + Bar string \`json:"bar"\` +} + +type Namespace1_IBar interface { + Method() + Bar() string +} + +// The jsii proxy for Namespace1_IBar +type jsiiProxy_Namespace1_IBar struct { + _ byte // padding +} + +func (n *jsiiProxy_Namespace1_IBar) Method() { + _jsii_.InvokeVoid( + n, + "method", + nil /* no parameters */, + ) +} + +func (j *jsiiProxy_Namespace1_IBar) Bar() string { + var returns string + _jsii_.Get( + j, + "bar", + &returns, + ) + return returns +} + +type Namespace2 interface { + Foo() +} + +// The jsii proxy struct for Namespace2 +type jsiiProxy_Namespace2 struct { + _ byte // padding +} + +func NewNamespace2() Namespace2 { + _init_.Initialize() + + j := jsiiProxy_Namespace2{} + + _jsii_.Create( + "testpkg.Namespace2", + nil /* no parameters */, + []_jsii_.FQN{}, + nil, // no overrides + &j, + ) + + return &j +} + +func (n *jsiiProxy_Namespace2) Foo() { + _jsii_.InvokeVoid( + n, + "foo", + nil /* no parameters */, + ) +} + +type Namespace2_Foo string + +const ( + Namespace2_Foo_BAR Namespace2_Foo = "BAR" + Namespace2_Foo_BAZ Namespace2_Foo = "BAZ" +) + +type Namespace2_Foo_Final interface { + Done() bool +} + +// The jsii proxy struct for Namespace2_Foo_Final +type jsiiProxy_Namespace2_Foo_Final struct { + _ byte // padding +} + +func (j *jsiiProxy_Namespace2_Foo_Final) Done() bool { + var returns bool + _jsii_.Get( + j, + "done", + &returns, + ) + return returns +} + + +func NewNamespace2_Foo_Final() Namespace2_Foo_Final { + _init_.Initialize() + + j := jsiiProxy_Namespace2_Foo_Final{} + + _jsii_.Create( + "testpkg.Namespace2.Foo.Final", + nil /* no parameters */, + []_jsii_.FQN{}, + nil, // no overrides + &j, + ) + + return &j +} + + +`; + +exports[`nested-types.ts: /go/testpkg/testpkg.init.go 1`] = ` +package testpkg + +import ( + "reflect" + + _jsii_ "github.com/aws/jsii-runtime-go" +) + +func init() { + _jsii_.RegisterClass( + "testpkg.Namespace1", + reflect.TypeOf((*Namespace1)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberMethod{JsiiMethod: "foo", GoMethod: "Foo"}, + }, + func() interface{} { + return &jsiiProxy_Namespace1{} + }, + ) + _jsii_.RegisterStruct( + "testpkg.Namespace1.Foo", + reflect.TypeOf((*Namespace1_Foo)(nil)).Elem(), + ) + _jsii_.RegisterInterface( + "testpkg.Namespace1.IBar", + reflect.TypeOf((*Namespace1_IBar)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberProperty{JsiiProperty: "bar", GoGetter: "Bar"}, + _jsii_.MemberMethod{JsiiMethod: "method", GoMethod: "Method"}, + }, + func() interface{} { + return &jsiiProxy_Namespace1_IBar{} + }, + ) + _jsii_.RegisterClass( + "testpkg.Namespace2", + reflect.TypeOf((*Namespace2)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberMethod{JsiiMethod: "foo", GoMethod: "Foo"}, + }, + func() interface{} { + return &jsiiProxy_Namespace2{} + }, + ) + _jsii_.RegisterEnum( + "testpkg.Namespace2.Foo", + reflect.TypeOf((*Namespace2_Foo)(nil)).Elem(), + map[string]interface{}{ + "BAR": Namespace2_Foo_BAR, + "BAZ": Namespace2_Foo_BAZ, + }, + ) + _jsii_.RegisterClass( + "testpkg.Namespace2.Foo.Final", + reflect.TypeOf((*Namespace2_Foo_Final)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberProperty{JsiiProperty: "done", GoGetter: "Done"}, + }, + func() interface{} { + return &jsiiProxy_Namespace2_Foo_Final{} + }, + ) +} + +`; + +exports[`nested-types.ts: /java/pom.xml 1`] = ` + + + 4.0.0 + \${project.groupId}:\${project.artifactId} + testpkg + https://github.com/aws/jsii.git + + + Apache License 2.0 + http://www.apache.org/licenses/LICENSE-2.0 + repo + An OSI-approved license + + + + + John Doe + + author + + + + + scm:git:https://github.com/aws/jsii.git + https://github.com/aws/jsii.git + + example.test + demo + 0.0.1 + jar + + UTF-8 + + + + software.amazon.jsii + jsii-runtime + (,0.0.1) + + + org.jetbrains + annotations + [16.0.3,20.0.0) + + + + javax.annotation + javax.annotation-api + [1.3.2,1.4.0) + compile + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 1.8 + 1.8 + + + + org.apache.maven.plugins + maven-jar-plugin + 3.2.0 + + + true + + true + true + + + + + + org.apache.maven.plugins + maven-source-plugin + 3.2.1 + + + attach-sources + + jar + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.2.0 + + + attach-javadocs + + jar + + + + + false + protected + + **/$Module.java + + -J-XX:+TieredCompilation + -J-XX:TieredStopAtLevel=1 + + + + org.apache.maven.plugins + maven-enforcer-plugin + 3.0.0-M3 + + + enforce-maven + + enforce + + + + + 3.6 + + + + + + + + org.codehaus.mojo + versions-maven-plugin + 2.8.1 + + false + + + + + + +`; + +exports[`nested-types.ts: /java/src/main/java/example/test/demo/$Module.java 1`] = ` +package example.test.demo; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.IOException; +import java.io.Reader; +import java.io.UncheckedIOException; + +import java.nio.charset.StandardCharsets; + +import java.util.HashMap; +import java.util.Map; + +import software.amazon.jsii.JsiiModule; + +@software.amazon.jsii.Internal +public final class $Module extends JsiiModule { + private static final Map MODULE_TYPES = load(); + + private static Map load() { + final Map result = new HashMap<>(); + final ClassLoader cl = $Module.class.getClassLoader(); + try (final InputStream is = cl.getResourceAsStream("example/test/demo/$Module.txt"); + final Reader rd = new InputStreamReader(is, StandardCharsets.UTF_8); + final BufferedReader br = new BufferedReader(rd)) { + br.lines() + .filter(line -> !line.trim().isEmpty()) + .forEach(line -> { + final String[] parts = line.split("=", 2); + final String fqn = parts[0]; + final String className = parts[1]; + result.put(fqn, className); + }); + } + catch (final IOException exception) { + throw new UncheckedIOException(exception); + } + return result; + } + + private final Map> cache = new HashMap<>(); + + public $Module() { + super("testpkg", "0.0.1", $Module.class, "testpkg@0.0.1.jsii.tgz"); + } + + @Override + protected Class resolveClass(final String fqn) throws ClassNotFoundException { + if (!MODULE_TYPES.containsKey(fqn)) { + throw new ClassNotFoundException("Unknown JSII type: " + fqn); + } + String className = MODULE_TYPES.get(fqn); + if (!this.cache.containsKey(className)) { + this.cache.put(className, this.findClass(className)); + } + return this.cache.get(className); + } + + private Class findClass(final String binaryName) { + try { + return Class.forName(binaryName); + } + catch (final ClassNotFoundException exception) { + throw new RuntimeException(exception); + } + } +} + +`; + +exports[`nested-types.ts: /java/src/main/java/example/test/demo/Namespace1.java 1`] = ` +package example.test.demo; + +@javax.annotation.Generated(value = "jsii-pacmak") +@software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace1") +public class Namespace1 extends software.amazon.jsii.JsiiObject { + + protected Namespace1(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + protected Namespace1(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) { + super(initializationMode); + } + + public Namespace1() { + super(software.amazon.jsii.JsiiObject.InitializationMode.JSII); + software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this); + } + + public void foo() { + software.amazon.jsii.Kernel.call(this, "foo", software.amazon.jsii.NativeType.VOID); + } + @software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace1.Foo") + @software.amazon.jsii.Jsii.Proxy(Foo.Jsii$Proxy.class) + public static interface Foo extends software.amazon.jsii.JsiiSerializable { + + @org.jetbrains.annotations.NotNull java.lang.String getBar(); + + /** + * @return a {@link Builder} of {@link Foo} + */ + static Builder builder() { + return new Builder(); + } + /** + * A builder for {@link Foo} + */ + public static final class Builder implements software.amazon.jsii.Builder { + private java.lang.String bar; + + /** + * Sets the value of {@link Foo#getBar} + * @param bar the value to be set. This parameter is required. + * @return {@code this} + */ + public Builder bar(java.lang.String bar) { + this.bar = bar; + return this; + } + + /** + * Builds the configured instance. + * @return a new instance of {@link Foo} + * @throws NullPointerException if any required attribute was not provided + */ + @Override + public Foo build() { + return new Jsii$Proxy(bar); + } + } + + /** + * An implementation for {@link Foo} + */ + @software.amazon.jsii.Internal + final class Jsii$Proxy extends software.amazon.jsii.JsiiObject implements Foo { + private final java.lang.String bar; + + /** + * Constructor that initializes the object based on values retrieved from the JsiiObject. + * @param objRef Reference to the JSII managed object. + */ + protected Jsii$Proxy(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + this.bar = software.amazon.jsii.Kernel.get(this, "bar", software.amazon.jsii.NativeType.forClass(java.lang.String.class)); + } + + /** + * Constructor that initializes the object based on literal property values passed by the {@link Builder}. + */ + protected Jsii$Proxy(final java.lang.String bar) { + super(software.amazon.jsii.JsiiObject.InitializationMode.JSII); + this.bar = java.util.Objects.requireNonNull(bar, "bar is required"); + } + + @Override + public final java.lang.String getBar() { + return this.bar; + } + + @Override + @software.amazon.jsii.Internal + public com.fasterxml.jackson.databind.JsonNode $jsii$toJson() { + final com.fasterxml.jackson.databind.ObjectMapper om = software.amazon.jsii.JsiiObjectMapper.INSTANCE; + final com.fasterxml.jackson.databind.node.ObjectNode data = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode(); + + data.set("bar", om.valueToTree(this.getBar())); + + final com.fasterxml.jackson.databind.node.ObjectNode struct = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode(); + struct.set("fqn", om.valueToTree("testpkg.Namespace1.Foo")); + struct.set("data", data); + + final com.fasterxml.jackson.databind.node.ObjectNode obj = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode(); + obj.set("$jsii.struct", struct); + + return obj; + } + + @Override + public final boolean equals(final Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Foo.Jsii$Proxy that = (Foo.Jsii$Proxy) o; + + return this.bar.equals(that.bar); + } + + @Override + public final int hashCode() { + int result = this.bar.hashCode(); + return result; + } + } + } + @software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace1.IBar") + @software.amazon.jsii.Jsii.Proxy(IBar.Jsii$Proxy.class) + public static interface IBar extends software.amazon.jsii.JsiiSerializable { + + @org.jetbrains.annotations.NotNull java.lang.String getBar(); + + void method(); + + /** + * A proxy class which represents a concrete javascript instance of this type. + */ + @software.amazon.jsii.Internal + final class Jsii$Proxy extends software.amazon.jsii.JsiiObject implements example.test.demo.Namespace1.IBar.Jsii$Default { + protected Jsii$Proxy(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + @Override + public final @org.jetbrains.annotations.NotNull java.lang.String getBar() { + return software.amazon.jsii.Kernel.get(this, "bar", software.amazon.jsii.NativeType.forClass(java.lang.String.class)); + } + + @Override + public final void method() { + software.amazon.jsii.Kernel.call(this, "method", software.amazon.jsii.NativeType.VOID); + } + } + + /** + * Internal default implementation for {@link IBar}. + */ + @software.amazon.jsii.Internal + interface Jsii$Default extends IBar { + + @Override + default @org.jetbrains.annotations.NotNull java.lang.String getBar() { + return software.amazon.jsii.Kernel.get(this, "bar", software.amazon.jsii.NativeType.forClass(java.lang.String.class)); + } + + @Override + default void method() { + software.amazon.jsii.Kernel.call(this, "method", software.amazon.jsii.NativeType.VOID); + } + } + } +} + +`; + +exports[`nested-types.ts: /java/src/main/java/example/test/demo/Namespace2.java 1`] = ` +package example.test.demo; + +@javax.annotation.Generated(value = "jsii-pacmak") +@software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace2") +public class Namespace2 extends software.amazon.jsii.JsiiObject { + + protected Namespace2(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + protected Namespace2(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) { + super(initializationMode); + } + + public Namespace2() { + super(software.amazon.jsii.JsiiObject.InitializationMode.JSII); + software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this); + } + + public void foo() { + software.amazon.jsii.Kernel.call(this, "foo", software.amazon.jsii.NativeType.VOID); + } + @software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace2.Foo") + public enum Foo { + BAR, + BAZ, + @software.amazon.jsii.Jsii(module = example.test.demo.$Module.class, fqn = "testpkg.Namespace2.Foo.Final") + public static class Final extends software.amazon.jsii.JsiiObject { + + protected Final(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + protected Final(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) { + super(initializationMode); + } + + public Final() { + super(software.amazon.jsii.JsiiObject.InitializationMode.JSII); + software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this); + } + + public @org.jetbrains.annotations.NotNull java.lang.Boolean getDone() { + return software.amazon.jsii.Kernel.get(this, "done", software.amazon.jsii.NativeType.forClass(java.lang.Boolean.class)); + } + } + } +} + +`; + +exports[`nested-types.ts: /java/src/main/resources/example/test/demo/$Module.txt 1`] = ` +testpkg.Namespace1=example.test.demo.Namespace1 +testpkg.Namespace1.Foo=example.test.demo.Namespace1$Foo +testpkg.Namespace1.IBar=example.test.demo.Namespace1$IBar +testpkg.Namespace2=example.test.demo.Namespace2 +testpkg.Namespace2.Foo=example.test.demo.Namespace2$Foo +testpkg.Namespace2.Foo.Final=example.test.demo.Namespace2$Foo.Final + +`; + +exports[`nested-types.ts: /python/pyproject.toml 1`] = ` +[build-system] +requires = ["setuptools~=53.0.0", "wheel~=0.36.2"] +build-backend = "setuptools.build_meta" + +`; + +exports[`nested-types.ts: /python/setup.py 1`] = ` +import json +import setuptools + +kwargs = json.loads( + """ +{ + "name": "example-test.demo", + "version": "0.0.1", + "description": "testpkg", + "license": "Apache-2.0", + "url": "https://github.com/aws/jsii.git", + "long_description_content_type": "text/markdown", + "author": "John Doe", + "bdist_wheel": { + "universal": true + }, + "project_urls": { + "Source": "https://github.com/aws/jsii.git" + }, + "package_dir": { + "": "src" + }, + "packages": [ + "example_test_demo", + "example_test_demo._jsii" + ], + "package_data": { + "example_test_demo._jsii": [ + "testpkg@0.0.1.jsii.tgz" + ], + "example_test_demo": [ + "py.typed" + ] + }, + "python_requires": ">=3.6", + "install_requires": [ + "jsii<0.0.1", + "publication>=0.0.3" + ], + "classifiers": [ + "Intended Audience :: Developers", + "Operating System :: OS Independent", + "Programming Language :: JavaScript", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Typing :: Typed", + "License :: OSI Approved" + ], + "scripts": [] +} +""" +) + +with open("README.md", encoding="utf8") as fp: + kwargs["long_description"] = fp.read() + + +setuptools.setup(**kwargs) + +`; + +exports[`nested-types.ts: /python/src/example_test_demo/__init__.py 1`] = ` +import abc +import builtins +import datetime +import enum +import typing + +import jsii +import publication +import typing_extensions + +from ._jsii import * + + +class Namespace1(metaclass=jsii.JSIIMeta, jsii_type="testpkg.Namespace1"): + def __init__(self) -> None: + jsii.create(Namespace1, self, []) + + @jsii.member(jsii_name="foo") + def foo(self) -> None: + return typing.cast(None, jsii.invoke(self, "foo", [])) + + @jsii.data_type( + jsii_type="testpkg.Namespace1.Foo", + jsii_struct_bases=[], + name_mapping={"bar": "bar"}, + ) + class Foo: + def __init__(self, *, bar: builtins.str) -> None: + ''' + :param bar: - + ''' + self._values: typing.Dict[str, typing.Any] = { + "bar": bar, + } + + @builtins.property + def bar(self) -> builtins.str: + result = self._values.get("bar") + assert result is not None, "Required property 'bar' is missing" + return typing.cast(builtins.str, result) + + def __eq__(self, rhs: typing.Any) -> builtins.bool: + return isinstance(rhs, self.__class__) and rhs._values == self._values + + def __ne__(self, rhs: typing.Any) -> builtins.bool: + return not (rhs == self) + + def __repr__(self) -> str: + return "Foo(%s)" % ", ".join( + k + "=" + repr(v) for k, v in self._values.items() + ) + + @jsii.interface(jsii_type="testpkg.Namespace1.IBar") + class IBar(typing_extensions.Protocol): + @builtins.staticmethod + def __jsii_proxy_class__() -> typing.Type["_IBarProxy"]: + return _IBarProxy + + @builtins.property # type: ignore[misc] + @jsii.member(jsii_name="bar") + def bar(self) -> builtins.str: + ... + + @jsii.member(jsii_name="method") + def method(self) -> None: + ... + + + class _IBarProxy: + __jsii_type__: typing.ClassVar[str] = "testpkg.Namespace1.IBar" + + @builtins.property # type: ignore[misc] + @jsii.member(jsii_name="bar") + def bar(self) -> builtins.str: + return typing.cast(builtins.str, jsii.get(self, "bar")) + + @jsii.member(jsii_name="method") + def method(self) -> None: + return typing.cast(None, jsii.invoke(self, "method", [])) + + +class Namespace2(metaclass=jsii.JSIIMeta, jsii_type="testpkg.Namespace2"): + def __init__(self) -> None: + jsii.create(Namespace2, self, []) + + @jsii.member(jsii_name="foo") + def foo(self) -> None: + return typing.cast(None, jsii.invoke(self, "foo", [])) + + @jsii.enum(jsii_type="testpkg.Namespace2.Foo") + class Foo(enum.Enum): + BAR = "BAR" + BAZ = "BAZ" + class Final(metaclass=jsii.JSIIMeta, jsii_type="testpkg.Namespace2.Foo.Final"): + def __init__(self) -> None: + jsii.create(Final, self, []) + + @builtins.property # type: ignore[misc] + @jsii.member(jsii_name="done") + def done(self) -> builtins.bool: + return typing.cast(builtins.bool, jsii.get(self, "done")) + + +__all__ = [ + "Namespace1", + "Namespace2", +] + +publication.publish() + +`; + +exports[`nested-types.ts: /python/src/example_test_demo/_jsii/__init__.py 1`] = ` +import abc +import builtins +import datetime +import enum +import typing + +import jsii +import publication +import typing_extensions + +__jsii_assembly__ = jsii.JSIIAssembly.load( + "testpkg", "0.0.1", __name__[0:-6], "testpkg@0.0.1.jsii.tgz" +) + +__all__ = [ + "__jsii_assembly__", +] + +publication.publish() + +`; + +exports[`nested-types.ts: /python/src/example_test_demo/py.typed 1`] = ` + + +`; diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.ts.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.ts.snap index acd616bda3..54851fb22d 100644 --- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.ts.snap +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.ts.snap @@ -287,28 +287,28 @@ type Base interface { } // The jsii proxy struct for Base -type base_jsiiProxy struct { +type jsiiProxy_Base struct { _ byte // padding } func NewBase() Base { _init_.Initialize() - b := base_jsiiProxy{} + j := jsiiProxy_Base{} _jsii_.Create( "@scope/jsii-calc-base.Base", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &b, + &j, ) - return &b + return &j } // Returns: the name of the class (to verify native type names are created for derived classes). -func (b *base_jsiiProxy) TypeName() interface{} { +func (b *jsiiProxy_Base) TypeName() interface{} { var returns interface{} _jsii_.Invoke( @@ -339,11 +339,11 @@ type IBaseInterface interface { } // The jsii proxy for IBaseInterface -type iBaseInterface_jsiiProxy struct { +type jsiiProxy_IBaseInterface struct { scopejsiicalcbaseofbase.IVeryBaseInterface // extends @scope/jsii-calc-base-of-base.IVeryBaseInterface } -func (i *iBaseInterface_jsiiProxy) Bar() { +func (i *jsiiProxy_IBaseInterface) Bar() { _jsii_.InvokeVoid( i, "bar", @@ -356,24 +356,24 @@ type StaticConsumer interface { } // The jsii proxy struct for StaticConsumer -type staticConsumer_jsiiProxy struct { +type jsiiProxy_StaticConsumer struct { _ byte // padding } func NewStaticConsumer() StaticConsumer { _init_.Initialize() - s := staticConsumer_jsiiProxy{} + j := jsiiProxy_StaticConsumer{} _jsii_.Create( "@scope/jsii-calc-base.StaticConsumer", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } func StaticConsumer_Consume(args interface{}) { @@ -406,7 +406,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "typeName", GoMethod: "TypeName"}, }, func() interface{} { - return &base_jsiiProxy{} + return &jsiiProxy_Base{} }, ) _jsii_.RegisterStruct( @@ -421,9 +421,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "foo", GoMethod: "Foo"}, }, func() interface{} { - i := iBaseInterface_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.IVeryBaseInterface) - return &i + j := jsiiProxy_IBaseInterface{} + _jsii_.InitJsiiProxy(&j.IVeryBaseInterface) + return &j }, ) _jsii_.RegisterClass( @@ -431,7 +431,7 @@ func init() { reflect.TypeOf((*StaticConsumer)(nil)).Elem(), nil, // no members func() interface{} { - return &staticConsumer_jsiiProxy{} + return &jsiiProxy_StaticConsumer{} }, ) } @@ -721,11 +721,11 @@ type IVeryBaseInterface interface { } // The jsii proxy for IVeryBaseInterface -type iVeryBaseInterface_jsiiProxy struct { +type jsiiProxy_IVeryBaseInterface struct { _ byte // padding } -func (i *iVeryBaseInterface_jsiiProxy) Foo() { +func (i *jsiiProxy_IVeryBaseInterface) Foo() { _jsii_.InvokeVoid( i, "foo", @@ -737,7 +737,7 @@ type StaticConsumer interface { } // The jsii proxy struct for StaticConsumer -type staticConsumer_jsiiProxy struct { +type jsiiProxy_StaticConsumer struct { _ byte // padding } @@ -758,7 +758,7 @@ type Very interface { } // The jsii proxy struct for Very -type very_jsiiProxy struct { +type jsiiProxy_Very struct { _ byte // padding } @@ -766,21 +766,21 @@ type very_jsiiProxy struct { func NewVery() Very { _init_.Initialize() - v := very_jsiiProxy{} + j := jsiiProxy_Very{} _jsii_.Create( "@scope/jsii-calc-base-of-base.Very", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &v, + &j, ) - return &v + return &j } // Experimental. -func (v *very_jsiiProxy) Hey() float64 { +func (v *jsiiProxy_Very) Hey() float64 { var returns float64 _jsii_.Invoke( @@ -817,7 +817,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "foo", GoMethod: "Foo"}, }, func() interface{} { - return &iVeryBaseInterface_jsiiProxy{} + return &jsiiProxy_IVeryBaseInterface{} }, ) _jsii_.RegisterClass( @@ -825,7 +825,7 @@ func init() { reflect.TypeOf((*StaticConsumer)(nil)).Elem(), nil, // no members func() interface{} { - return &staticConsumer_jsiiProxy{} + return &jsiiProxy_StaticConsumer{} }, ) _jsii_.RegisterClass( @@ -835,7 +835,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hey", GoMethod: "Hey"}, }, func() interface{} { - return &very_jsiiProxy{} + return &jsiiProxy_Very{} }, ) _jsii_.RegisterStruct( @@ -1173,14 +1173,14 @@ type IDoublable interface { } // The jsii proxy for IDoublable -type iDoublable_jsiiProxy struct { +type jsiiProxy_IDoublable struct { _ byte // padding } -func (i *iDoublable_jsiiProxy) DoubleValue() float64 { +func (j *jsiiProxy_IDoublable) DoubleValue() float64 { var returns float64 _jsii_.Get( - i, + j, "doubleValue", &returns, ) @@ -1199,11 +1199,11 @@ type IFriendly interface { } // The jsii proxy for IFriendly -type iFriendly_jsiiProxy struct { +type jsiiProxy_IFriendly struct { _ byte // padding } -func (i *iFriendly_jsiiProxy) Hello() string { +func (i *jsiiProxy_IFriendly) Hello() string { var returns string _jsii_.Invoke( @@ -1228,11 +1228,11 @@ type IThreeLevelsInterface interface { } // The jsii proxy for IThreeLevelsInterface -type iThreeLevelsInterface_jsiiProxy struct { +type jsiiProxy_IThreeLevelsInterface struct { scopejsiicalcbase.IBaseInterface // extends @scope/jsii-calc-base.IBaseInterface } -func (i *iThreeLevelsInterface_jsiiProxy) Baz() { +func (i *jsiiProxy_IThreeLevelsInterface) Baz() { _jsii_.InvokeVoid( i, "baz", @@ -1263,25 +1263,25 @@ type Number interface { } // The jsii proxy struct for Number -type number_jsiiProxy struct { - numericValue_jsiiProxy // extends @scope/jsii-calc-lib.NumericValue - iDoublable_jsiiProxy // implements @scope/jsii-calc-lib.IDoublable +type jsiiProxy_Number struct { + jsiiProxy_NumericValue // extends @scope/jsii-calc-lib.NumericValue + jsiiProxy_IDoublable // implements @scope/jsii-calc-lib.IDoublable } -func (n *number_jsiiProxy) DoubleValue() float64 { +func (j *jsiiProxy_Number) DoubleValue() float64 { var returns float64 _jsii_.Get( - n, + j, "doubleValue", &returns, ) return returns } -func (n *number_jsiiProxy) Value() float64 { +func (j *jsiiProxy_Number) Value() float64 { var returns float64 _jsii_.Get( - n, + j, "value", &returns, ) @@ -1294,22 +1294,22 @@ func (n *number_jsiiProxy) Value() float64 { func NewNumber(value float64) Number { _init_.Initialize() - n := number_jsiiProxy{} + j := jsiiProxy_Number{} _jsii_.Create( "@scope/jsii-calc-lib.Number", []interface{}{value}, []_jsii_.FQN{"@scope/jsii-calc-lib.IDoublable"}, nil, // no overrides - &n, + &j, ) - return &n + return &j } // String representation of the value. // Deprecated. -func (n *number_jsiiProxy) ToString() string { +func (n *jsiiProxy_Number) ToString() string { var returns string _jsii_.Invoke( @@ -1324,7 +1324,7 @@ func (n *number_jsiiProxy) ToString() string { // Returns: the name of the class (to verify native type names are created for derived classes). // Deprecated. -func (n *number_jsiiProxy) TypeName() interface{} { +func (n *jsiiProxy_Number) TypeName() interface{} { var returns interface{} _jsii_.Invoke( @@ -1346,14 +1346,14 @@ type NumericValue interface { } // The jsii proxy struct for NumericValue -type numericValue_jsiiProxy struct { +type jsiiProxy_NumericValue struct { scopejsiicalcbase.Base // extends @scope/jsii-calc-base.Base } -func (n *numericValue_jsiiProxy) Value() float64 { +func (j *jsiiProxy_NumericValue) Value() float64 { var returns float64 _jsii_.Get( - n, + j, "value", &returns, ) @@ -1365,22 +1365,22 @@ func (n *numericValue_jsiiProxy) Value() float64 { func NewNumericValue() NumericValue { _init_.Initialize() - n := numericValue_jsiiProxy{} + j := jsiiProxy_NumericValue{} _jsii_.Create( "@scope/jsii-calc-lib.NumericValue", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &n, + &j, ) - return &n + return &j } // String representation of the value. // Deprecated. -func (n *numericValue_jsiiProxy) ToString() string { +func (n *jsiiProxy_NumericValue) ToString() string { var returns string _jsii_.Invoke( @@ -1401,30 +1401,30 @@ type Operation interface { } // The jsii proxy struct for Operation -type operation_jsiiProxy struct { - numericValue_jsiiProxy // extends @scope/jsii-calc-lib.NumericValue +type jsiiProxy_Operation struct { + jsiiProxy_NumericValue // extends @scope/jsii-calc-lib.NumericValue } // Deprecated. func NewOperation() Operation { _init_.Initialize() - o := operation_jsiiProxy{} + j := jsiiProxy_Operation{} _jsii_.Create( "@scope/jsii-calc-lib.Operation", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } // String representation of the value. // Deprecated. -func (o *operation_jsiiProxy) ToString() string { +func (o *jsiiProxy_Operation) ToString() string { var returns string _jsii_.Invoke( @@ -1485,7 +1485,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "doubleValue", GoGetter: "DoubleValue"}, }, func() interface{} { - return &iDoublable_jsiiProxy{} + return &jsiiProxy_IDoublable{} }, ) _jsii_.RegisterInterface( @@ -1495,7 +1495,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - return &iFriendly_jsiiProxy{} + return &jsiiProxy_IFriendly{} }, ) _jsii_.RegisterInterface( @@ -1507,9 +1507,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "foo", GoMethod: "Foo"}, }, func() interface{} { - i := iThreeLevelsInterface_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.IBaseInterface) - return &i + j := jsiiProxy_IThreeLevelsInterface{} + _jsii_.InitJsiiProxy(&j.IBaseInterface) + return &j }, ) _jsii_.RegisterStruct( @@ -1526,10 +1526,10 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - n := number_jsiiProxy{} - _jsii_.InitJsiiProxy(&n.numericValue_jsiiProxy) - _jsii_.InitJsiiProxy(&n.iDoublable_jsiiProxy) - return &n + j := jsiiProxy_Number{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_NumericValue) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IDoublable) + return &j }, ) _jsii_.RegisterClass( @@ -1541,9 +1541,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - n := numericValue_jsiiProxy{} - _jsii_.InitJsiiProxy(&n.Base) - return &n + j := jsiiProxy_NumericValue{} + _jsii_.InitJsiiProxy(&j.Base) + return &j }, ) _jsii_.RegisterClass( @@ -1555,9 +1555,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - o := operation_jsiiProxy{} - _jsii_.InitJsiiProxy(&o.numericValue_jsiiProxy) - return &o + j := jsiiProxy_Operation{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_NumericValue) + return &j }, ) _jsii_.RegisterStruct( @@ -1583,14 +1583,14 @@ type IReflectable interface { } // The jsii proxy for IReflectable -type iReflectable_jsiiProxy struct { +type jsiiProxy_IReflectable struct { _ byte // padding } -func (i *iReflectable_jsiiProxy) Entries() []ReflectableEntry { +func (j *jsiiProxy_IReflectable) Entries() []ReflectableEntry { var returns []ReflectableEntry _jsii_.Get( - i, + j, "entries", &returns, ) @@ -1603,25 +1603,25 @@ type NestingClass interface { } // The jsii proxy struct for NestingClass -type nestingClass_jsiiProxy struct { +type jsiiProxy_NestingClass struct { _ byte // padding } // This class is here to show we can use nested classes across module boundaries. // Deprecated. -type NestedClass interface { +type NestingClass_NestedClass interface { Property() string } -// The jsii proxy struct for NestedClass -type nestedClass_jsiiProxy struct { +// The jsii proxy struct for NestingClass_NestedClass +type jsiiProxy_NestingClass_NestedClass struct { _ byte // padding } -func (n *nestedClass_jsiiProxy) Property() string { +func (j *jsiiProxy_NestingClass_NestedClass) Property() string { var returns string _jsii_.Get( - n, + j, "property", &returns, ) @@ -1630,27 +1630,27 @@ func (n *nestedClass_jsiiProxy) Property() string { // Deprecated. -func NewNestedClass() NestedClass { +func NewNestingClass_NestedClass() NestingClass_NestedClass { _init_.Initialize() - n := nestedClass_jsiiProxy{} + j := jsiiProxy_NestingClass_NestedClass{} _jsii_.Create( "@scope/jsii-calc-lib.submodule.NestingClass.NestedClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &n, + &j, ) - return &n + return &j } // This is a struct, nested within a class. // // Normal. // Deprecated. -type NestedStruct struct { +type NestingClass_NestedStruct struct { // Deprecated. Name string \`json:"name"\` } @@ -1669,7 +1669,7 @@ type Reflector interface { } // The jsii proxy struct for Reflector -type reflector_jsiiProxy struct { +type jsiiProxy_Reflector struct { _ byte // padding } @@ -1677,21 +1677,21 @@ type reflector_jsiiProxy struct { func NewReflector() Reflector { _init_.Initialize() - r := reflector_jsiiProxy{} + j := jsiiProxy_Reflector{} _jsii_.Create( "@scope/jsii-calc-lib.submodule.Reflector", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &r, + &j, ) - return &r + return &j } // Deprecated. -func (r *reflector_jsiiProxy) AsMap(reflectable IReflectable) map[string]interface{} { +func (r *jsiiProxy_Reflector) AsMap(reflectable IReflectable) map[string]interface{} { var returns map[string]interface{} _jsii_.Invoke( @@ -1724,7 +1724,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "entries", GoGetter: "Entries"}, }, func() interface{} { - return &iReflectable_jsiiProxy{} + return &jsiiProxy_IReflectable{} }, ) _jsii_.RegisterClass( @@ -1732,22 +1732,22 @@ func init() { reflect.TypeOf((*NestingClass)(nil)).Elem(), nil, // no members func() interface{} { - return &nestingClass_jsiiProxy{} + return &jsiiProxy_NestingClass{} }, ) _jsii_.RegisterClass( "@scope/jsii-calc-lib.submodule.NestingClass.NestedClass", - reflect.TypeOf((*NestedClass)(nil)).Elem(), + reflect.TypeOf((*NestingClass_NestedClass)(nil)).Elem(), []_jsii_.Member{ _jsii_.MemberProperty{JsiiProperty: "property", GoGetter: "Property"}, }, func() interface{} { - return &nestedClass_jsiiProxy{} + return &jsiiProxy_NestingClass_NestedClass{} }, ) _jsii_.RegisterStruct( "@scope/jsii-calc-lib.submodule.NestingClass.NestedStruct", - reflect.TypeOf((*NestedStruct)(nil)).Elem(), + reflect.TypeOf((*NestingClass_NestedStruct)(nil)).Elem(), ) _jsii_.RegisterStruct( "@scope/jsii-calc-lib.submodule.ReflectableEntry", @@ -1760,7 +1760,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "asMap", GoMethod: "AsMap"}, }, func() interface{} { - return &reflector_jsiiProxy{} + return &jsiiProxy_Reflector{} }, ) } @@ -2097,61 +2097,61 @@ type CompositeOperation interface { DecorationPrefixes() []string SetDecorationPrefixes(val []string) Expression() scopejsiicalclib.NumericValue - StringStyle() CompositionStringStyle - SetStringStyle(val CompositionStringStyle) + StringStyle() CompositeOperation_CompositionStringStyle + SetStringStyle(val CompositeOperation_CompositionStringStyle) Value() float64 ToString() string } // The jsii proxy struct for CompositeOperation -type compositeOperation_jsiiProxy struct { +type jsiiProxy_CompositeOperation struct { scopejsiicalclib.Operation // extends @scope/jsii-calc-lib.Operation } -func (c *compositeOperation_jsiiProxy) DecorationPostfixes() []string { +func (j *jsiiProxy_CompositeOperation) DecorationPostfixes() []string { var returns []string _jsii_.Get( - c, + j, "decorationPostfixes", &returns, ) return returns } -func (c *compositeOperation_jsiiProxy) DecorationPrefixes() []string { +func (j *jsiiProxy_CompositeOperation) DecorationPrefixes() []string { var returns []string _jsii_.Get( - c, + j, "decorationPrefixes", &returns, ) return returns } -func (c *compositeOperation_jsiiProxy) Expression() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_CompositeOperation) Expression() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - c, + j, "expression", &returns, ) return returns } -func (c *compositeOperation_jsiiProxy) StringStyle() CompositionStringStyle { - var returns CompositionStringStyle +func (j *jsiiProxy_CompositeOperation) StringStyle() CompositeOperation_CompositionStringStyle { + var returns CompositeOperation_CompositionStringStyle _jsii_.Get( - c, + j, "stringStyle", &returns, ) return returns } -func (c *compositeOperation_jsiiProxy) Value() float64 { +func (j *jsiiProxy_CompositeOperation) Value() float64 { var returns float64 _jsii_.Get( - c, + j, "value", &returns, ) @@ -2162,45 +2162,45 @@ func (c *compositeOperation_jsiiProxy) Value() float64 { func NewCompositeOperation() CompositeOperation { _init_.Initialize() - c := compositeOperation_jsiiProxy{} + j := jsiiProxy_CompositeOperation{} _jsii_.Create( "jsii-calc.composition.CompositeOperation", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *compositeOperation_jsiiProxy) SetDecorationPostfixes(val []string) { +func (j *jsiiProxy_CompositeOperation) SetDecorationPostfixes(val []string) { _jsii_.Set( - c, + j, "decorationPostfixes", val, ) } -func (c *compositeOperation_jsiiProxy) SetDecorationPrefixes(val []string) { +func (j *jsiiProxy_CompositeOperation) SetDecorationPrefixes(val []string) { _jsii_.Set( - c, + j, "decorationPrefixes", val, ) } -func (c *compositeOperation_jsiiProxy) SetStringStyle(val CompositionStringStyle) { +func (j *jsiiProxy_CompositeOperation) SetStringStyle(val CompositeOperation_CompositionStringStyle) { _jsii_.Set( - c, + j, "stringStyle", val, ) } // (deprecated) String representation of the value. -func (c *compositeOperation_jsiiProxy) ToString() string { +func (c *jsiiProxy_CompositeOperation) ToString() string { var returns string _jsii_.Invoke( @@ -2214,11 +2214,11 @@ func (c *compositeOperation_jsiiProxy) ToString() string { } // Style of .toString() output for CompositeOperation. -type CompositionStringStyle string +type CompositeOperation_CompositionStringStyle string const ( - CompositionStringStyle_NORMAL CompositionStringStyle = "NORMAL" - CompositionStringStyle_DECORATED CompositionStringStyle = "DECORATED" + CompositeOperation_CompositionStringStyle_NORMAL CompositeOperation_CompositionStringStyle = "NORMAL" + CompositeOperation_CompositionStringStyle_DECORATED CompositeOperation_CompositionStringStyle = "DECORATED" ) @@ -2247,17 +2247,17 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - c := compositeOperation_jsiiProxy{} - _jsii_.InitJsiiProxy(&c.Operation) - return &c + j := jsiiProxy_CompositeOperation{} + _jsii_.InitJsiiProxy(&j.Operation) + return &j }, ) _jsii_.RegisterEnum( "jsii-calc.composition.CompositeOperation.CompositionStringStyle", - reflect.TypeOf((*CompositionStringStyle)(nil)).Elem(), + reflect.TypeOf((*CompositeOperation_CompositionStringStyle)(nil)).Elem(), map[string]interface{}{ - "NORMAL": CompositionStringStyle_NORMAL, - "DECORATED": CompositionStringStyle_DECORATED, + "NORMAL": CompositeOperation_CompositionStringStyle_NORMAL, + "DECORATED": CompositeOperation_CompositionStringStyle_DECORATED, }, ) } @@ -2278,14 +2278,14 @@ type Base interface { } // The jsii proxy struct for Base -type base_jsiiProxy struct { +type jsiiProxy_Base struct { _ byte // padding } -func (b *base_jsiiProxy) Prop() string { +func (j *jsiiProxy_Base) Prop() string { var returns string _jsii_.Get( - b, + j, "prop", &returns, ) @@ -2296,22 +2296,22 @@ func (b *base_jsiiProxy) Prop() string { func NewBase() Base { _init_.Initialize() - b := base_jsiiProxy{} + j := jsiiProxy_Base{} _jsii_.Create( "jsii-calc.DerivedClassHasNoProperties.Base", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &b, + &j, ) - return &b + return &j } -func (b *base_jsiiProxy) SetProp(val string) { +func (j *jsiiProxy_Base) SetProp(val string) { _jsii_.Set( - b, + j, "prop", val, ) @@ -2322,24 +2322,24 @@ type Derived interface { } // The jsii proxy struct for Derived -type derived_jsiiProxy struct { - base_jsiiProxy // extends jsii-calc.DerivedClassHasNoProperties.Base +type jsiiProxy_Derived struct { + jsiiProxy_Base // extends jsii-calc.DerivedClassHasNoProperties.Base } func NewDerived() Derived { _init_.Initialize() - d := derived_jsiiProxy{} + j := jsiiProxy_Derived{} _jsii_.Create( "jsii-calc.DerivedClassHasNoProperties.Derived", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } @@ -2362,7 +2362,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "prop", GoGetter: "Prop"}, }, func() interface{} { - return &base_jsiiProxy{} + return &jsiiProxy_Base{} }, ) _jsii_.RegisterClass( @@ -2372,9 +2372,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "prop", GoGetter: "Prop"}, }, func() interface{} { - d := derived_jsiiProxy{} - _jsii_.InitJsiiProxy(&d.base_jsiiProxy) - return &d + j := jsiiProxy_Derived{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_Base) + return &j }, ) } @@ -2409,14 +2409,14 @@ type Foo interface { } // The jsii proxy struct for Foo -type foo_jsiiProxy struct { +type jsiiProxy_Foo struct { _ byte // padding } -func (f *foo_jsiiProxy) Bar() string { +func (j *jsiiProxy_Foo) Bar() string { var returns string _jsii_.Get( - f, + j, "bar", &returns, ) @@ -2427,22 +2427,22 @@ func (f *foo_jsiiProxy) Bar() string { func NewFoo() Foo { _init_.Initialize() - f := foo_jsiiProxy{} + j := jsiiProxy_Foo{} _jsii_.Create( "jsii-calc.InterfaceInNamespaceIncludesClasses.Foo", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &f, + &j, ) - return &f + return &j } -func (f *foo_jsiiProxy) SetBar(val string) { +func (j *jsiiProxy_Foo) SetBar(val string) { _jsii_.Set( - f, + j, "bar", val, ) @@ -2472,7 +2472,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "bar", GoGetter: "Bar"}, }, func() interface{} { - return &foo_jsiiProxy{} + return &jsiiProxy_Foo{} }, ) _jsii_.RegisterStruct( @@ -2570,15 +2570,15 @@ type AbstractClass interface { } // The jsii proxy struct for AbstractClass -type abstractClass_jsiiProxy struct { - abstractClassBase_jsiiProxy // extends jsii-calc.AbstractClassBase - iInterfaceImplementedByAbstractClass_jsiiProxy // implements jsii-calc.IInterfaceImplementedByAbstractClass +type jsiiProxy_AbstractClass struct { + jsiiProxy_AbstractClassBase // extends jsii-calc.AbstractClassBase + jsiiProxy_IInterfaceImplementedByAbstractClass // implements jsii-calc.IInterfaceImplementedByAbstractClass } -func (a *abstractClass_jsiiProxy) PropFromInterface() string { +func (j *jsiiProxy_AbstractClass) PropFromInterface() string { var returns string _jsii_.Get( - a, + j, "propFromInterface", &returns, ) @@ -2589,20 +2589,20 @@ func (a *abstractClass_jsiiProxy) PropFromInterface() string { func NewAbstractClass() AbstractClass { _init_.Initialize() - a := abstractClass_jsiiProxy{} + j := jsiiProxy_AbstractClass{} _jsii_.Create( "jsii-calc.AbstractClass", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IInterfaceImplementedByAbstractClass"}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *abstractClass_jsiiProxy) AbstractMethod(name string) string { +func (a *jsiiProxy_AbstractClass) AbstractMethod(name string) string { var returns string _jsii_.Invoke( @@ -2615,7 +2615,7 @@ func (a *abstractClass_jsiiProxy) AbstractMethod(name string) string { return returns } -func (a *abstractClass_jsiiProxy) NonAbstractMethod() float64 { +func (a *jsiiProxy_AbstractClass) NonAbstractMethod() float64 { var returns float64 _jsii_.Invoke( @@ -2633,14 +2633,14 @@ type AbstractClassBase interface { } // The jsii proxy struct for AbstractClassBase -type abstractClassBase_jsiiProxy struct { +type jsiiProxy_AbstractClassBase struct { _ byte // padding } -func (a *abstractClassBase_jsiiProxy) AbstractProperty() string { +func (j *jsiiProxy_AbstractClassBase) AbstractProperty() string { var returns string _jsii_.Get( - a, + j, "abstractProperty", &returns, ) @@ -2651,17 +2651,17 @@ func (a *abstractClassBase_jsiiProxy) AbstractProperty() string { func NewAbstractClassBase() AbstractClassBase { _init_.Initialize() - a := abstractClassBase_jsiiProxy{} + j := jsiiProxy_AbstractClassBase{} _jsii_.Create( "jsii-calc.AbstractClassBase", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } type AbstractClassReturner interface { @@ -2671,14 +2671,14 @@ type AbstractClassReturner interface { } // The jsii proxy struct for AbstractClassReturner -type abstractClassReturner_jsiiProxy struct { +type jsiiProxy_AbstractClassReturner struct { _ byte // padding } -func (a *abstractClassReturner_jsiiProxy) ReturnAbstractFromProperty() AbstractClassBase { +func (j *jsiiProxy_AbstractClassReturner) ReturnAbstractFromProperty() AbstractClassBase { var returns AbstractClassBase _jsii_.Get( - a, + j, "returnAbstractFromProperty", &returns, ) @@ -2689,20 +2689,20 @@ func (a *abstractClassReturner_jsiiProxy) ReturnAbstractFromProperty() AbstractC func NewAbstractClassReturner() AbstractClassReturner { _init_.Initialize() - a := abstractClassReturner_jsiiProxy{} + j := jsiiProxy_AbstractClassReturner{} _jsii_.Create( "jsii-calc.AbstractClassReturner", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *abstractClassReturner_jsiiProxy) GiveMeAbstract() AbstractClass { +func (a *jsiiProxy_AbstractClassReturner) GiveMeAbstract() AbstractClass { var returns AbstractClass _jsii_.Invoke( @@ -2715,7 +2715,7 @@ func (a *abstractClassReturner_jsiiProxy) GiveMeAbstract() AbstractClass { return returns } -func (a *abstractClassReturner_jsiiProxy) GiveMeInterface() IInterfaceImplementedByAbstractClass { +func (a *jsiiProxy_AbstractClassReturner) GiveMeInterface() IInterfaceImplementedByAbstractClass { var returns IInterfaceImplementedByAbstractClass _jsii_.Invoke( @@ -2736,14 +2736,14 @@ type AbstractSuite interface { } // The jsii proxy struct for AbstractSuite -type abstractSuite_jsiiProxy struct { +type jsiiProxy_AbstractSuite struct { _ byte // padding } -func (a *abstractSuite_jsiiProxy) Property() string { +func (j *jsiiProxy_AbstractSuite) Property() string { var returns string _jsii_.Get( - a, + j, "property", &returns, ) @@ -2754,28 +2754,28 @@ func (a *abstractSuite_jsiiProxy) Property() string { func NewAbstractSuite() AbstractSuite { _init_.Initialize() - a := abstractSuite_jsiiProxy{} + j := jsiiProxy_AbstractSuite{} _jsii_.Create( "jsii-calc.AbstractSuite", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *abstractSuite_jsiiProxy) SetProperty(val string) { +func (j *jsiiProxy_AbstractSuite) SetProperty(val string) { _jsii_.Set( - a, + j, "property", val, ) } -func (a *abstractSuite_jsiiProxy) SomeMethod(str string) string { +func (a *jsiiProxy_AbstractSuite) SomeMethod(str string) string { var returns string _jsii_.Invoke( @@ -2789,7 +2789,7 @@ func (a *abstractSuite_jsiiProxy) SomeMethod(str string) string { } // Sets \`seed\` to \`this.property\`, then calls \`someMethod\` with \`this.property\` and returns the result. -func (a *abstractSuite_jsiiProxy) WorkItAll(seed string) string { +func (a *jsiiProxy_AbstractSuite) WorkItAll(seed string) string { var returns string _jsii_.Invoke( @@ -2810,14 +2810,14 @@ type Add interface { } // The jsii proxy struct for Add -type add_jsiiProxy struct { - binaryOperation_jsiiProxy // extends jsii-calc.BinaryOperation +type jsiiProxy_Add struct { + jsiiProxy_BinaryOperation // extends jsii-calc.BinaryOperation } -func (a *add_jsiiProxy) Value() float64 { +func (j *jsiiProxy_Add) Value() float64 { var returns float64 _jsii_.Get( - a, + j, "value", &returns, ) @@ -2829,21 +2829,21 @@ func (a *add_jsiiProxy) Value() float64 { func NewAdd(lhs scopejsiicalclib.NumericValue, rhs scopejsiicalclib.NumericValue) Add { _init_.Initialize() - a := add_jsiiProxy{} + j := jsiiProxy_Add{} _jsii_.Create( "jsii-calc.Add", []interface{}{lhs, rhs}, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } // (deprecated) String representation of the value. -func (a *add_jsiiProxy) ToString() string { +func (a *jsiiProxy_Add) ToString() string { var returns string _jsii_.Invoke( @@ -2904,194 +2904,194 @@ type AllTypes interface { } // The jsii proxy struct for AllTypes -type allTypes_jsiiProxy struct { +type jsiiProxy_AllTypes struct { _ byte // padding } -func (a *allTypes_jsiiProxy) AnyArrayProperty() []interface{} { +func (j *jsiiProxy_AllTypes) AnyArrayProperty() []interface{} { var returns []interface{} _jsii_.Get( - a, + j, "anyArrayProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) AnyMapProperty() map[string]interface{} { +func (j *jsiiProxy_AllTypes) AnyMapProperty() map[string]interface{} { var returns map[string]interface{} _jsii_.Get( - a, + j, "anyMapProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) AnyProperty() interface{} { +func (j *jsiiProxy_AllTypes) AnyProperty() interface{} { var returns interface{} _jsii_.Get( - a, + j, "anyProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) ArrayProperty() []string { +func (j *jsiiProxy_AllTypes) ArrayProperty() []string { var returns []string _jsii_.Get( - a, + j, "arrayProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) BooleanProperty() bool { +func (j *jsiiProxy_AllTypes) BooleanProperty() bool { var returns bool _jsii_.Get( - a, + j, "booleanProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) DateProperty() string { +func (j *jsiiProxy_AllTypes) DateProperty() string { var returns string _jsii_.Get( - a, + j, "dateProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) EnumProperty() AllTypesEnum { +func (j *jsiiProxy_AllTypes) EnumProperty() AllTypesEnum { var returns AllTypesEnum _jsii_.Get( - a, + j, "enumProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) EnumPropertyValue() float64 { +func (j *jsiiProxy_AllTypes) EnumPropertyValue() float64 { var returns float64 _jsii_.Get( - a, + j, "enumPropertyValue", &returns, ) return returns } -func (a *allTypes_jsiiProxy) JsonProperty() map[string]interface{} { +func (j *jsiiProxy_AllTypes) JsonProperty() map[string]interface{} { var returns map[string]interface{} _jsii_.Get( - a, + j, "jsonProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) MapProperty() map[string]scopejsiicalclib.Number { +func (j *jsiiProxy_AllTypes) MapProperty() map[string]scopejsiicalclib.Number { var returns map[string]scopejsiicalclib.Number _jsii_.Get( - a, + j, "mapProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) NumberProperty() float64 { +func (j *jsiiProxy_AllTypes) NumberProperty() float64 { var returns float64 _jsii_.Get( - a, + j, "numberProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) OptionalEnumValue() StringEnum { +func (j *jsiiProxy_AllTypes) OptionalEnumValue() StringEnum { var returns StringEnum _jsii_.Get( - a, + j, "optionalEnumValue", &returns, ) return returns } -func (a *allTypes_jsiiProxy) StringProperty() string { +func (j *jsiiProxy_AllTypes) StringProperty() string { var returns string _jsii_.Get( - a, + j, "stringProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnionArrayProperty() []interface{} { +func (j *jsiiProxy_AllTypes) UnionArrayProperty() []interface{} { var returns []interface{} _jsii_.Get( - a, + j, "unionArrayProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnionMapProperty() map[string]interface{} { +func (j *jsiiProxy_AllTypes) UnionMapProperty() map[string]interface{} { var returns map[string]interface{} _jsii_.Get( - a, + j, "unionMapProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnionProperty() interface{} { +func (j *jsiiProxy_AllTypes) UnionProperty() interface{} { var returns interface{} _jsii_.Get( - a, + j, "unionProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnknownArrayProperty() []interface{} { +func (j *jsiiProxy_AllTypes) UnknownArrayProperty() []interface{} { var returns []interface{} _jsii_.Get( - a, + j, "unknownArrayProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnknownMapProperty() map[string]interface{} { +func (j *jsiiProxy_AllTypes) UnknownMapProperty() map[string]interface{} { var returns map[string]interface{} _jsii_.Get( - a, + j, "unknownMapProperty", &returns, ) return returns } -func (a *allTypes_jsiiProxy) UnknownProperty() interface{} { +func (j *jsiiProxy_AllTypes) UnknownProperty() interface{} { var returns interface{} _jsii_.Get( - a, + j, "unknownProperty", &returns, ) @@ -3102,164 +3102,164 @@ func (a *allTypes_jsiiProxy) UnknownProperty() interface{} { func NewAllTypes() AllTypes { _init_.Initialize() - a := allTypes_jsiiProxy{} + j := jsiiProxy_AllTypes{} _jsii_.Create( "jsii-calc.AllTypes", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *allTypes_jsiiProxy) SetAnyArrayProperty(val []interface{}) { +func (j *jsiiProxy_AllTypes) SetAnyArrayProperty(val []interface{}) { _jsii_.Set( - a, + j, "anyArrayProperty", val, ) } -func (a *allTypes_jsiiProxy) SetAnyMapProperty(val map[string]interface{}) { +func (j *jsiiProxy_AllTypes) SetAnyMapProperty(val map[string]interface{}) { _jsii_.Set( - a, + j, "anyMapProperty", val, ) } -func (a *allTypes_jsiiProxy) SetAnyProperty(val interface{}) { +func (j *jsiiProxy_AllTypes) SetAnyProperty(val interface{}) { _jsii_.Set( - a, + j, "anyProperty", val, ) } -func (a *allTypes_jsiiProxy) SetArrayProperty(val []string) { +func (j *jsiiProxy_AllTypes) SetArrayProperty(val []string) { _jsii_.Set( - a, + j, "arrayProperty", val, ) } -func (a *allTypes_jsiiProxy) SetBooleanProperty(val bool) { +func (j *jsiiProxy_AllTypes) SetBooleanProperty(val bool) { _jsii_.Set( - a, + j, "booleanProperty", val, ) } -func (a *allTypes_jsiiProxy) SetDateProperty(val string) { +func (j *jsiiProxy_AllTypes) SetDateProperty(val string) { _jsii_.Set( - a, + j, "dateProperty", val, ) } -func (a *allTypes_jsiiProxy) SetEnumProperty(val AllTypesEnum) { +func (j *jsiiProxy_AllTypes) SetEnumProperty(val AllTypesEnum) { _jsii_.Set( - a, + j, "enumProperty", val, ) } -func (a *allTypes_jsiiProxy) SetJsonProperty(val map[string]interface{}) { +func (j *jsiiProxy_AllTypes) SetJsonProperty(val map[string]interface{}) { _jsii_.Set( - a, + j, "jsonProperty", val, ) } -func (a *allTypes_jsiiProxy) SetMapProperty(val map[string]scopejsiicalclib.Number) { +func (j *jsiiProxy_AllTypes) SetMapProperty(val map[string]scopejsiicalclib.Number) { _jsii_.Set( - a, + j, "mapProperty", val, ) } -func (a *allTypes_jsiiProxy) SetNumberProperty(val float64) { +func (j *jsiiProxy_AllTypes) SetNumberProperty(val float64) { _jsii_.Set( - a, + j, "numberProperty", val, ) } -func (a *allTypes_jsiiProxy) SetOptionalEnumValue(val StringEnum) { +func (j *jsiiProxy_AllTypes) SetOptionalEnumValue(val StringEnum) { _jsii_.Set( - a, + j, "optionalEnumValue", val, ) } -func (a *allTypes_jsiiProxy) SetStringProperty(val string) { +func (j *jsiiProxy_AllTypes) SetStringProperty(val string) { _jsii_.Set( - a, + j, "stringProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnionArrayProperty(val []interface{}) { +func (j *jsiiProxy_AllTypes) SetUnionArrayProperty(val []interface{}) { _jsii_.Set( - a, + j, "unionArrayProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnionMapProperty(val map[string]interface{}) { +func (j *jsiiProxy_AllTypes) SetUnionMapProperty(val map[string]interface{}) { _jsii_.Set( - a, + j, "unionMapProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnionProperty(val interface{}) { +func (j *jsiiProxy_AllTypes) SetUnionProperty(val interface{}) { _jsii_.Set( - a, + j, "unionProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnknownArrayProperty(val []interface{}) { +func (j *jsiiProxy_AllTypes) SetUnknownArrayProperty(val []interface{}) { _jsii_.Set( - a, + j, "unknownArrayProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnknownMapProperty(val map[string]interface{}) { +func (j *jsiiProxy_AllTypes) SetUnknownMapProperty(val map[string]interface{}) { _jsii_.Set( - a, + j, "unknownMapProperty", val, ) } -func (a *allTypes_jsiiProxy) SetUnknownProperty(val interface{}) { +func (j *jsiiProxy_AllTypes) SetUnknownProperty(val interface{}) { _jsii_.Set( - a, + j, "unknownProperty", val, ) } -func (a *allTypes_jsiiProxy) AnyIn(inp interface{}) { +func (a *jsiiProxy_AllTypes) AnyIn(inp interface{}) { _jsii_.InvokeVoid( a, "anyIn", @@ -3267,7 +3267,7 @@ func (a *allTypes_jsiiProxy) AnyIn(inp interface{}) { ) } -func (a *allTypes_jsiiProxy) AnyOut() interface{} { +func (a *jsiiProxy_AllTypes) AnyOut() interface{} { var returns interface{} _jsii_.Invoke( @@ -3280,7 +3280,7 @@ func (a *allTypes_jsiiProxy) AnyOut() interface{} { return returns } -func (a *allTypes_jsiiProxy) EnumMethod(value StringEnum) StringEnum { +func (a *jsiiProxy_AllTypes) EnumMethod(value StringEnum) StringEnum { var returns StringEnum _jsii_.Invoke( @@ -3309,27 +3309,27 @@ type AllowedMethodNames interface { } // The jsii proxy struct for AllowedMethodNames -type allowedMethodNames_jsiiProxy struct { +type jsiiProxy_AllowedMethodNames struct { _ byte // padding } func NewAllowedMethodNames() AllowedMethodNames { _init_.Initialize() - a := allowedMethodNames_jsiiProxy{} + j := jsiiProxy_AllowedMethodNames{} _jsii_.Create( "jsii-calc.AllowedMethodNames", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *allowedMethodNames_jsiiProxy) GetBar(_p1 string, _p2 float64) { +func (a *jsiiProxy_AllowedMethodNames) GetBar(_p1 string, _p2 float64) { _jsii_.InvokeVoid( a, "getBar", @@ -3338,7 +3338,7 @@ func (a *allowedMethodNames_jsiiProxy) GetBar(_p1 string, _p2 float64) { } // getXxx() is not allowed (see negatives), but getXxx(a, ...) is okay. -func (a *allowedMethodNames_jsiiProxy) GetFoo(withParam string) string { +func (a *jsiiProxy_AllowedMethodNames) GetFoo(withParam string) string { var returns string _jsii_.Invoke( @@ -3351,7 +3351,7 @@ func (a *allowedMethodNames_jsiiProxy) GetFoo(withParam string) string { return returns } -func (a *allowedMethodNames_jsiiProxy) SetBar(_x string, _y float64, _z bool) { +func (a *jsiiProxy_AllowedMethodNames) SetBar(_x string, _y float64, _z bool) { _jsii_.InvokeVoid( a, "setBar", @@ -3360,7 +3360,7 @@ func (a *allowedMethodNames_jsiiProxy) SetBar(_x string, _y float64, _z bool) { } // setFoo(x) is not allowed (see negatives), but setXxx(a, b, ...) is okay. -func (a *allowedMethodNames_jsiiProxy) SetFoo(_x string, _y float64) { +func (a *jsiiProxy_AllowedMethodNames) SetFoo(_x string, _y float64) { _jsii_.InvokeVoid( a, "setFoo", @@ -3374,24 +3374,24 @@ type AmbiguousParameters interface { } // The jsii proxy struct for AmbiguousParameters -type ambiguousParameters_jsiiProxy struct { +type jsiiProxy_AmbiguousParameters struct { _ byte // padding } -func (a *ambiguousParameters_jsiiProxy) Props() StructParameterType { +func (j *jsiiProxy_AmbiguousParameters) Props() StructParameterType { var returns StructParameterType _jsii_.Get( - a, + j, "props", &returns, ) return returns } -func (a *ambiguousParameters_jsiiProxy) Scope() Bell { +func (j *jsiiProxy_AmbiguousParameters) Scope() Bell { var returns Bell _jsii_.Get( - a, + j, "scope", &returns, ) @@ -3402,17 +3402,17 @@ func (a *ambiguousParameters_jsiiProxy) Scope() Bell { func NewAmbiguousParameters(scope Bell, props StructParameterType) AmbiguousParameters { _init_.Initialize() - a := ambiguousParameters_jsiiProxy{} + j := jsiiProxy_AmbiguousParameters{} _jsii_.Create( "jsii-calc.AmbiguousParameters", []interface{}{scope, props}, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } type AnonymousImplementationProvider interface { @@ -3422,27 +3422,27 @@ type AnonymousImplementationProvider interface { } // The jsii proxy struct for AnonymousImplementationProvider -type anonymousImplementationProvider_jsiiProxy struct { - iAnonymousImplementationProvider_jsiiProxy // implements jsii-calc.IAnonymousImplementationProvider +type jsiiProxy_AnonymousImplementationProvider struct { + jsiiProxy_IAnonymousImplementationProvider // implements jsii-calc.IAnonymousImplementationProvider } func NewAnonymousImplementationProvider() AnonymousImplementationProvider { _init_.Initialize() - a := anonymousImplementationProvider_jsiiProxy{} + j := jsiiProxy_AnonymousImplementationProvider{} _jsii_.Create( "jsii-calc.AnonymousImplementationProvider", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IAnonymousImplementationProvider"}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *anonymousImplementationProvider_jsiiProxy) ProvideAsClass() Implementation { +func (a *jsiiProxy_AnonymousImplementationProvider) ProvideAsClass() Implementation { var returns Implementation _jsii_.Invoke( @@ -3455,7 +3455,7 @@ func (a *anonymousImplementationProvider_jsiiProxy) ProvideAsClass() Implementat return returns } -func (a *anonymousImplementationProvider_jsiiProxy) ProvideAsInterface() IAnonymouslyImplementMe { +func (a *jsiiProxy_AnonymousImplementationProvider) ProvideAsInterface() IAnonymouslyImplementMe { var returns IAnonymouslyImplementMe _jsii_.Invoke( @@ -3478,27 +3478,27 @@ type AsyncVirtualMethods interface { } // The jsii proxy struct for AsyncVirtualMethods -type asyncVirtualMethods_jsiiProxy struct { +type jsiiProxy_AsyncVirtualMethods struct { _ byte // padding } func NewAsyncVirtualMethods() AsyncVirtualMethods { _init_.Initialize() - a := asyncVirtualMethods_jsiiProxy{} + j := jsiiProxy_AsyncVirtualMethods{} _jsii_.Create( "jsii-calc.AsyncVirtualMethods", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *asyncVirtualMethods_jsiiProxy) CallMe() float64 { +func (a *jsiiProxy_AsyncVirtualMethods) CallMe() float64 { var returns float64 _jsii_.Invoke( @@ -3512,7 +3512,7 @@ func (a *asyncVirtualMethods_jsiiProxy) CallMe() float64 { } // Just calls "overrideMeToo". -func (a *asyncVirtualMethods_jsiiProxy) CallMe2() float64 { +func (a *jsiiProxy_AsyncVirtualMethods) CallMe2() float64 { var returns float64 _jsii_.Invoke( @@ -3530,7 +3530,7 @@ func (a *asyncVirtualMethods_jsiiProxy) CallMe2() float64 { // This is a "double promise" situation, which // means that callbacks are not going to be available immediate, but only // after an "immediates" cycle. -func (a *asyncVirtualMethods_jsiiProxy) CallMeDoublePromise() float64 { +func (a *jsiiProxy_AsyncVirtualMethods) CallMeDoublePromise() float64 { var returns float64 _jsii_.Invoke( @@ -3543,7 +3543,7 @@ func (a *asyncVirtualMethods_jsiiProxy) CallMeDoublePromise() float64 { return returns } -func (a *asyncVirtualMethods_jsiiProxy) DontOverrideMe() float64 { +func (a *jsiiProxy_AsyncVirtualMethods) DontOverrideMe() float64 { var returns float64 _jsii_.Invoke( @@ -3556,7 +3556,7 @@ func (a *asyncVirtualMethods_jsiiProxy) DontOverrideMe() float64 { return returns } -func (a *asyncVirtualMethods_jsiiProxy) OverrideMe(mult float64) float64 { +func (a *jsiiProxy_AsyncVirtualMethods) OverrideMe(mult float64) float64 { var returns float64 _jsii_.Invoke( @@ -3569,7 +3569,7 @@ func (a *asyncVirtualMethods_jsiiProxy) OverrideMe(mult float64) float64 { return returns } -func (a *asyncVirtualMethods_jsiiProxy) OverrideMeToo() float64 { +func (a *jsiiProxy_AsyncVirtualMethods) OverrideMeToo() float64 { var returns float64 _jsii_.Invoke( @@ -3588,27 +3588,27 @@ type AugmentableClass interface { } // The jsii proxy struct for AugmentableClass -type augmentableClass_jsiiProxy struct { +type jsiiProxy_AugmentableClass struct { _ byte // padding } func NewAugmentableClass() AugmentableClass { _init_.Initialize() - a := augmentableClass_jsiiProxy{} + j := jsiiProxy_AugmentableClass{} _jsii_.Create( "jsii-calc.AugmentableClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &a, + &j, ) - return &a + return &j } -func (a *augmentableClass_jsiiProxy) MethodOne() { +func (a *jsiiProxy_AugmentableClass) MethodOne() { _jsii_.InvokeVoid( a, "methodOne", @@ -3616,7 +3616,7 @@ func (a *augmentableClass_jsiiProxy) MethodOne() { ) } -func (a *augmentableClass_jsiiProxy) MethodTwo() { +func (a *jsiiProxy_AugmentableClass) MethodTwo() { _jsii_.InvokeVoid( a, "methodTwo", @@ -3628,24 +3628,24 @@ type BaseJsii976 interface { } // The jsii proxy struct for BaseJsii976 -type baseJsii976_jsiiProxy struct { +type jsiiProxy_BaseJsii976 struct { _ byte // padding } func NewBaseJsii976() BaseJsii976 { _init_.Initialize() - b := baseJsii976_jsiiProxy{} + j := jsiiProxy_BaseJsii976{} _jsii_.Create( "jsii-calc.BaseJsii976", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &b, + &j, ) - return &b + return &j } type Bell interface { @@ -3656,14 +3656,14 @@ type Bell interface { } // The jsii proxy struct for Bell -type bell_jsiiProxy struct { - iBell_jsiiProxy // implements jsii-calc.IBell +type jsiiProxy_Bell struct { + jsiiProxy_IBell // implements jsii-calc.IBell } -func (b *bell_jsiiProxy) Rung() bool { +func (j *jsiiProxy_Bell) Rung() bool { var returns bool _jsii_.Get( - b, + j, "rung", &returns, ) @@ -3674,28 +3674,28 @@ func (b *bell_jsiiProxy) Rung() bool { func NewBell() Bell { _init_.Initialize() - b := bell_jsiiProxy{} + j := jsiiProxy_Bell{} _jsii_.Create( "jsii-calc.Bell", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IBell"}, nil, // no overrides - &b, + &j, ) - return &b + return &j } -func (b *bell_jsiiProxy) SetRung(val bool) { +func (j *jsiiProxy_Bell) SetRung(val bool) { _jsii_.Set( - b, + j, "rung", val, ) } -func (b *bell_jsiiProxy) Ring() { +func (b *jsiiProxy_Bell) Ring() { _jsii_.InvokeVoid( b, "ring", @@ -3713,35 +3713,35 @@ type BinaryOperation interface { } // The jsii proxy struct for BinaryOperation -type binaryOperation_jsiiProxy struct { +type jsiiProxy_BinaryOperation struct { scopejsiicalclib.Operation // extends @scope/jsii-calc-lib.Operation scopejsiicalclib.IFriendly // implements @scope/jsii-calc-lib.IFriendly } -func (b *binaryOperation_jsiiProxy) Lhs() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_BinaryOperation) Lhs() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - b, + j, "lhs", &returns, ) return returns } -func (b *binaryOperation_jsiiProxy) Rhs() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_BinaryOperation) Rhs() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - b, + j, "rhs", &returns, ) return returns } -func (b *binaryOperation_jsiiProxy) Value() float64 { +func (j *jsiiProxy_BinaryOperation) Value() float64 { var returns float64 _jsii_.Get( - b, + j, "value", &returns, ) @@ -3753,21 +3753,21 @@ func (b *binaryOperation_jsiiProxy) Value() float64 { func NewBinaryOperation(lhs scopejsiicalclib.NumericValue, rhs scopejsiicalclib.NumericValue) BinaryOperation { _init_.Initialize() - b := binaryOperation_jsiiProxy{} + j := jsiiProxy_BinaryOperation{} _jsii_.Create( "jsii-calc.BinaryOperation", []interface{}{lhs, rhs}, []_jsii_.FQN{"@scope/jsii-calc-lib.IFriendly"}, nil, // no overrides - &b, + &j, ) - return &b + return &j } // (deprecated) Say hello! -func (b *binaryOperation_jsiiProxy) Hello() string { +func (b *jsiiProxy_BinaryOperation) Hello() string { var returns string _jsii_.Invoke( @@ -3782,7 +3782,7 @@ func (b *binaryOperation_jsiiProxy) Hello() string { // String representation of the value. // Deprecated. -func (b *binaryOperation_jsiiProxy) ToString() string { +func (b *jsiiProxy_BinaryOperation) ToString() string { var returns string _jsii_.Invoke( @@ -3796,7 +3796,7 @@ func (b *binaryOperation_jsiiProxy) ToString() string { } // Returns: the name of the class (to verify native type names are created for derived classes). -func (b *binaryOperation_jsiiProxy) TypeName() interface{} { +func (b *jsiiProxy_BinaryOperation) TypeName() interface{} { var returns interface{} _jsii_.Invoke( @@ -3816,27 +3816,27 @@ type BurriedAnonymousObject interface { } // The jsii proxy struct for BurriedAnonymousObject -type burriedAnonymousObject_jsiiProxy struct { +type jsiiProxy_BurriedAnonymousObject struct { _ byte // padding } func NewBurriedAnonymousObject() BurriedAnonymousObject { _init_.Initialize() - b := burriedAnonymousObject_jsiiProxy{} + j := jsiiProxy_BurriedAnonymousObject{} _jsii_.Create( "jsii-calc.BurriedAnonymousObject", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &b, + &j, ) - return &b + return &j } -func (b *burriedAnonymousObject_jsiiProxy) Check() bool { +func (b *jsiiProxy_BurriedAnonymousObject) Check() bool { var returns bool _jsii_.Invoke( @@ -3852,7 +3852,7 @@ func (b *burriedAnonymousObject_jsiiProxy) Check() bool { // Implement this method and have it return it's parameter. // // Returns: \`value\` -func (b *burriedAnonymousObject_jsiiProxy) GiveItBack(value interface{}) interface{} { +func (b *jsiiProxy_BurriedAnonymousObject) GiveItBack(value interface{}) interface{} { var returns interface{} _jsii_.Invoke( @@ -3899,64 +3899,64 @@ type Calculator interface { } // The jsii proxy struct for Calculator -type calculator_jsiiProxy struct { +type jsiiProxy_Calculator struct { composition.CompositeOperation // extends jsii-calc.composition.CompositeOperation } -func (c *calculator_jsiiProxy) Curr() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Calculator) Curr() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - c, + j, "curr", &returns, ) return returns } -func (c *calculator_jsiiProxy) Expression() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Calculator) Expression() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - c, + j, "expression", &returns, ) return returns } -func (c *calculator_jsiiProxy) MaxValue() float64 { +func (j *jsiiProxy_Calculator) MaxValue() float64 { var returns float64 _jsii_.Get( - c, + j, "maxValue", &returns, ) return returns } -func (c *calculator_jsiiProxy) OperationsLog() []scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Calculator) OperationsLog() []scopejsiicalclib.NumericValue { var returns []scopejsiicalclib.NumericValue _jsii_.Get( - c, + j, "operationsLog", &returns, ) return returns } -func (c *calculator_jsiiProxy) OperationsMap() map[string][]scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Calculator) OperationsMap() map[string][]scopejsiicalclib.NumericValue { var returns map[string][]scopejsiicalclib.NumericValue _jsii_.Get( - c, + j, "operationsMap", &returns, ) return returns } -func (c *calculator_jsiiProxy) UnionProperty() interface{} { +func (j *jsiiProxy_Calculator) UnionProperty() interface{} { var returns interface{} _jsii_.Get( - c, + j, "unionProperty", &returns, ) @@ -3968,45 +3968,45 @@ func (c *calculator_jsiiProxy) UnionProperty() interface{} { func NewCalculator(props CalculatorProps) Calculator { _init_.Initialize() - c := calculator_jsiiProxy{} + j := jsiiProxy_Calculator{} _jsii_.Create( "jsii-calc.Calculator", []interface{}{props}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *calculator_jsiiProxy) SetCurr(val scopejsiicalclib.NumericValue) { +func (j *jsiiProxy_Calculator) SetCurr(val scopejsiicalclib.NumericValue) { _jsii_.Set( - c, + j, "curr", val, ) } -func (c *calculator_jsiiProxy) SetMaxValue(val float64) { +func (j *jsiiProxy_Calculator) SetMaxValue(val float64) { _jsii_.Set( - c, + j, "maxValue", val, ) } -func (c *calculator_jsiiProxy) SetUnionProperty(val interface{}) { +func (j *jsiiProxy_Calculator) SetUnionProperty(val interface{}) { _jsii_.Set( - c, + j, "unionProperty", val, ) } // Adds a number to the current value. -func (c *calculator_jsiiProxy) Add(value float64) { +func (c *jsiiProxy_Calculator) Add(value float64) { _jsii_.InvokeVoid( c, "add", @@ -4015,7 +4015,7 @@ func (c *calculator_jsiiProxy) Add(value float64) { } // Multiplies the current value by a number. -func (c *calculator_jsiiProxy) Mul(value float64) { +func (c *jsiiProxy_Calculator) Mul(value float64) { _jsii_.InvokeVoid( c, "mul", @@ -4024,7 +4024,7 @@ func (c *calculator_jsiiProxy) Mul(value float64) { } // Negates the current value. -func (c *calculator_jsiiProxy) Neg() { +func (c *jsiiProxy_Calculator) Neg() { _jsii_.InvokeVoid( c, "neg", @@ -4033,7 +4033,7 @@ func (c *calculator_jsiiProxy) Neg() { } // Raises the current value by a power. -func (c *calculator_jsiiProxy) Pow(value float64) { +func (c *jsiiProxy_Calculator) Pow(value float64) { _jsii_.InvokeVoid( c, "pow", @@ -4042,7 +4042,7 @@ func (c *calculator_jsiiProxy) Pow(value float64) { } // Returns teh value of the union property (if defined). -func (c *calculator_jsiiProxy) ReadUnionValue() float64 { +func (c *jsiiProxy_Calculator) ReadUnionValue() float64 { var returns float64 _jsii_.Invoke( @@ -4090,44 +4090,44 @@ type ClassThatImplementsTheInternalInterface interface { } // The jsii proxy struct for ClassThatImplementsTheInternalInterface -type classThatImplementsTheInternalInterface_jsiiProxy struct { - iNonInternalInterface_jsiiProxy // implements jsii-calc.INonInternalInterface +type jsiiProxy_ClassThatImplementsTheInternalInterface struct { + jsiiProxy_INonInternalInterface // implements jsii-calc.INonInternalInterface } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) A() string { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) A() string { var returns string _jsii_.Get( - c, + j, "a", &returns, ) return returns } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) B() string { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) B() string { var returns string _jsii_.Get( - c, + j, "b", &returns, ) return returns } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) C() string { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) C() string { var returns string _jsii_.Get( - c, + j, "c", &returns, ) return returns } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) D() string { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) D() string { var returns string _jsii_.Get( - c, + j, "d", &returns, ) @@ -4138,46 +4138,46 @@ func (c *classThatImplementsTheInternalInterface_jsiiProxy) D() string { func NewClassThatImplementsTheInternalInterface() ClassThatImplementsTheInternalInterface { _init_.Initialize() - c := classThatImplementsTheInternalInterface_jsiiProxy{} + j := jsiiProxy_ClassThatImplementsTheInternalInterface{} _jsii_.Create( "jsii-calc.ClassThatImplementsTheInternalInterface", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.INonInternalInterface"}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) SetA(val string) { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) SetA(val string) { _jsii_.Set( - c, + j, "a", val, ) } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) SetB(val string) { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) SetB(val string) { _jsii_.Set( - c, + j, "b", val, ) } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) SetC(val string) { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) SetC(val string) { _jsii_.Set( - c, + j, "c", val, ) } -func (c *classThatImplementsTheInternalInterface_jsiiProxy) SetD(val string) { +func (j *jsiiProxy_ClassThatImplementsTheInternalInterface) SetD(val string) { _jsii_.Set( - c, + j, "d", val, ) @@ -4196,44 +4196,44 @@ type ClassThatImplementsThePrivateInterface interface { } // The jsii proxy struct for ClassThatImplementsThePrivateInterface -type classThatImplementsThePrivateInterface_jsiiProxy struct { - iNonInternalInterface_jsiiProxy // implements jsii-calc.INonInternalInterface +type jsiiProxy_ClassThatImplementsThePrivateInterface struct { + jsiiProxy_INonInternalInterface // implements jsii-calc.INonInternalInterface } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) A() string { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) A() string { var returns string _jsii_.Get( - c, + j, "a", &returns, ) return returns } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) B() string { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) B() string { var returns string _jsii_.Get( - c, + j, "b", &returns, ) return returns } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) C() string { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) C() string { var returns string _jsii_.Get( - c, + j, "c", &returns, ) return returns } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) E() string { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) E() string { var returns string _jsii_.Get( - c, + j, "e", &returns, ) @@ -4244,46 +4244,46 @@ func (c *classThatImplementsThePrivateInterface_jsiiProxy) E() string { func NewClassThatImplementsThePrivateInterface() ClassThatImplementsThePrivateInterface { _init_.Initialize() - c := classThatImplementsThePrivateInterface_jsiiProxy{} + j := jsiiProxy_ClassThatImplementsThePrivateInterface{} _jsii_.Create( "jsii-calc.ClassThatImplementsThePrivateInterface", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.INonInternalInterface"}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) SetA(val string) { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) SetA(val string) { _jsii_.Set( - c, + j, "a", val, ) } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) SetB(val string) { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) SetB(val string) { _jsii_.Set( - c, + j, "b", val, ) } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) SetC(val string) { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) SetC(val string) { _jsii_.Set( - c, + j, "c", val, ) } -func (c *classThatImplementsThePrivateInterface_jsiiProxy) SetE(val string) { +func (j *jsiiProxy_ClassThatImplementsThePrivateInterface) SetE(val string) { _jsii_.Set( - c, + j, "e", val, ) @@ -4297,24 +4297,24 @@ type ClassWithCollections interface { } // The jsii proxy struct for ClassWithCollections -type classWithCollections_jsiiProxy struct { +type jsiiProxy_ClassWithCollections struct { _ byte // padding } -func (c *classWithCollections_jsiiProxy) Array() []string { +func (j *jsiiProxy_ClassWithCollections) Array() []string { var returns []string _jsii_.Get( - c, + j, "array", &returns, ) return returns } -func (c *classWithCollections_jsiiProxy) Map() map[string]string { +func (j *jsiiProxy_ClassWithCollections) Map() map[string]string { var returns map[string]string _jsii_.Get( - c, + j, "map", &returns, ) @@ -4325,30 +4325,30 @@ func (c *classWithCollections_jsiiProxy) Map() map[string]string { func NewClassWithCollections(map_ map[string]string, array []string) ClassWithCollections { _init_.Initialize() - c := classWithCollections_jsiiProxy{} + j := jsiiProxy_ClassWithCollections{} _jsii_.Create( "jsii-calc.ClassWithCollections", []interface{}{map_, array}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classWithCollections_jsiiProxy) SetArray(val []string) { +func (j *jsiiProxy_ClassWithCollections) SetArray(val []string) { _jsii_.Set( - c, + j, "array", val, ) } -func (c *classWithCollections_jsiiProxy) SetMap(val map[string]string) { +func (j *jsiiProxy_ClassWithCollections) SetMap(val map[string]string) { _jsii_.Set( - c, + j, "map", val, ) @@ -4436,24 +4436,24 @@ type ClassWithDocs interface { } // The jsii proxy struct for ClassWithDocs -type classWithDocs_jsiiProxy struct { +type jsiiProxy_ClassWithDocs struct { _ byte // padding } func NewClassWithDocs() ClassWithDocs { _init_.Initialize() - c := classWithDocs_jsiiProxy{} + j := jsiiProxy_ClassWithDocs{} _jsii_.Create( "jsii-calc.ClassWithDocs", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } type ClassWithJavaReservedWords interface { @@ -4462,14 +4462,14 @@ type ClassWithJavaReservedWords interface { } // The jsii proxy struct for ClassWithJavaReservedWords -type classWithJavaReservedWords_jsiiProxy struct { +type jsiiProxy_ClassWithJavaReservedWords struct { _ byte // padding } -func (c *classWithJavaReservedWords_jsiiProxy) Int() string { +func (j *jsiiProxy_ClassWithJavaReservedWords) Int() string { var returns string _jsii_.Get( - c, + j, "int", &returns, ) @@ -4480,20 +4480,20 @@ func (c *classWithJavaReservedWords_jsiiProxy) Int() string { func NewClassWithJavaReservedWords(int string) ClassWithJavaReservedWords { _init_.Initialize() - c := classWithJavaReservedWords_jsiiProxy{} + j := jsiiProxy_ClassWithJavaReservedWords{} _jsii_.Create( "jsii-calc.ClassWithJavaReservedWords", []interface{}{int}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classWithJavaReservedWords_jsiiProxy) Import(assert string) string { +func (c *jsiiProxy_ClassWithJavaReservedWords) Import(assert string) string { var returns string _jsii_.Invoke( @@ -4512,14 +4512,14 @@ type ClassWithMutableObjectLiteralProperty interface { } // The jsii proxy struct for ClassWithMutableObjectLiteralProperty -type classWithMutableObjectLiteralProperty_jsiiProxy struct { +type jsiiProxy_ClassWithMutableObjectLiteralProperty struct { _ byte // padding } -func (c *classWithMutableObjectLiteralProperty_jsiiProxy) MutableObject() IMutableObjectLiteral { +func (j *jsiiProxy_ClassWithMutableObjectLiteralProperty) MutableObject() IMutableObjectLiteral { var returns IMutableObjectLiteral _jsii_.Get( - c, + j, "mutableObject", &returns, ) @@ -4530,22 +4530,22 @@ func (c *classWithMutableObjectLiteralProperty_jsiiProxy) MutableObject() IMutab func NewClassWithMutableObjectLiteralProperty() ClassWithMutableObjectLiteralProperty { _init_.Initialize() - c := classWithMutableObjectLiteralProperty_jsiiProxy{} + j := jsiiProxy_ClassWithMutableObjectLiteralProperty{} _jsii_.Create( "jsii-calc.ClassWithMutableObjectLiteralProperty", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classWithMutableObjectLiteralProperty_jsiiProxy) SetMutableObject(val IMutableObjectLiteral) { +func (j *jsiiProxy_ClassWithMutableObjectLiteralProperty) SetMutableObject(val IMutableObjectLiteral) { _jsii_.Set( - c, + j, "mutableObject", val, ) @@ -4560,24 +4560,24 @@ type ClassWithPrivateConstructorAndAutomaticProperties interface { } // The jsii proxy struct for ClassWithPrivateConstructorAndAutomaticProperties -type classWithPrivateConstructorAndAutomaticProperties_jsiiProxy struct { - iInterfaceWithProperties_jsiiProxy // implements jsii-calc.IInterfaceWithProperties +type jsiiProxy_ClassWithPrivateConstructorAndAutomaticProperties struct { + jsiiProxy_IInterfaceWithProperties // implements jsii-calc.IInterfaceWithProperties } -func (c *classWithPrivateConstructorAndAutomaticProperties_jsiiProxy) ReadOnlyString() string { +func (j *jsiiProxy_ClassWithPrivateConstructorAndAutomaticProperties) ReadOnlyString() string { var returns string _jsii_.Get( - c, + j, "readOnlyString", &returns, ) return returns } -func (c *classWithPrivateConstructorAndAutomaticProperties_jsiiProxy) ReadWriteString() string { +func (j *jsiiProxy_ClassWithPrivateConstructorAndAutomaticProperties) ReadWriteString() string { var returns string _jsii_.Get( - c, + j, "readWriteString", &returns, ) @@ -4585,9 +4585,9 @@ func (c *classWithPrivateConstructorAndAutomaticProperties_jsiiProxy) ReadWriteS } -func (c *classWithPrivateConstructorAndAutomaticProperties_jsiiProxy) SetReadWriteString(val string) { +func (j *jsiiProxy_ClassWithPrivateConstructorAndAutomaticProperties) SetReadWriteString(val string) { _jsii_.Set( - c, + j, "readWriteString", val, ) @@ -4617,14 +4617,14 @@ type ConfusingToJackson interface { } // The jsii proxy struct for ConfusingToJackson -type confusingToJackson_jsiiProxy struct { +type jsiiProxy_ConfusingToJackson struct { _ byte // padding } -func (c *confusingToJackson_jsiiProxy) UnionProperty() interface{} { +func (j *jsiiProxy_ConfusingToJackson) UnionProperty() interface{} { var returns interface{} _jsii_.Get( - c, + j, "unionProperty", &returns, ) @@ -4632,9 +4632,9 @@ func (c *confusingToJackson_jsiiProxy) UnionProperty() interface{} { } -func (c *confusingToJackson_jsiiProxy) SetUnionProperty(val interface{}) { +func (j *jsiiProxy_ConfusingToJackson) SetUnionProperty(val interface{}) { _jsii_.Set( - c, + j, "unionProperty", val, ) @@ -4678,48 +4678,48 @@ type ConstructorPassesThisOut interface { } // The jsii proxy struct for ConstructorPassesThisOut -type constructorPassesThisOut_jsiiProxy struct { +type jsiiProxy_ConstructorPassesThisOut struct { _ byte // padding } func NewConstructorPassesThisOut(consumer PartiallyInitializedThisConsumer) ConstructorPassesThisOut { _init_.Initialize() - c := constructorPassesThisOut_jsiiProxy{} + j := jsiiProxy_ConstructorPassesThisOut{} _jsii_.Create( "jsii-calc.ConstructorPassesThisOut", []interface{}{consumer}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } type Constructors interface { } // The jsii proxy struct for Constructors -type constructors_jsiiProxy struct { +type jsiiProxy_Constructors struct { _ byte // padding } func NewConstructors() Constructors { _init_.Initialize() - c := constructors_jsiiProxy{} + j := jsiiProxy_Constructors{} _jsii_.Create( "jsii-calc.Constructors", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } func Constructors_HiddenInterface() IPublicInterface { @@ -4832,27 +4832,27 @@ type ConsumePureInterface interface { } // The jsii proxy struct for ConsumePureInterface -type consumePureInterface_jsiiProxy struct { +type jsiiProxy_ConsumePureInterface struct { _ byte // padding } func NewConsumePureInterface(delegate IStructReturningDelegate) ConsumePureInterface { _init_.Initialize() - c := consumePureInterface_jsiiProxy{} + j := jsiiProxy_ConsumePureInterface{} _jsii_.Create( "jsii-calc.ConsumePureInterface", []interface{}{delegate}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *consumePureInterface_jsiiProxy) WorkItBaby() StructB { +func (c *jsiiProxy_ConsumePureInterface) WorkItBaby() StructB { var returns StructB _jsii_.Invoke( @@ -4877,24 +4877,24 @@ type ConsumerCanRingBell interface { } // The jsii proxy struct for ConsumerCanRingBell -type consumerCanRingBell_jsiiProxy struct { +type jsiiProxy_ConsumerCanRingBell struct { _ byte // padding } func NewConsumerCanRingBell() ConsumerCanRingBell { _init_.Initialize() - c := consumerCanRingBell_jsiiProxy{} + j := jsiiProxy_ConsumerCanRingBell{} _jsii_.Create( "jsii-calc.ConsumerCanRingBell", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } // ...if the interface is implemented using an object literal. @@ -4972,7 +4972,7 @@ func ConsumerCanRingBell_StaticWhenTypedAsClass(ringer IConcreteBellRinger) bool // ...if the interface is implemented using an object literal. // // Returns whether the bell was rung. -func (c *consumerCanRingBell_jsiiProxy) ImplementedByObjectLiteral(ringer IBellRinger) bool { +func (c *jsiiProxy_ConsumerCanRingBell) ImplementedByObjectLiteral(ringer IBellRinger) bool { var returns bool _jsii_.Invoke( @@ -4988,7 +4988,7 @@ func (c *consumerCanRingBell_jsiiProxy) ImplementedByObjectLiteral(ringer IBellR // ...if the interface is implemented using a private class. // // Return whether the bell was rung. -func (c *consumerCanRingBell_jsiiProxy) ImplementedByPrivateClass(ringer IBellRinger) bool { +func (c *jsiiProxy_ConsumerCanRingBell) ImplementedByPrivateClass(ringer IBellRinger) bool { var returns bool _jsii_.Invoke( @@ -5004,7 +5004,7 @@ func (c *consumerCanRingBell_jsiiProxy) ImplementedByPrivateClass(ringer IBellRi // ...if the interface is implemented using a public class. // // Return whether the bell was rung. -func (c *consumerCanRingBell_jsiiProxy) ImplementedByPublicClass(ringer IBellRinger) bool { +func (c *jsiiProxy_ConsumerCanRingBell) ImplementedByPublicClass(ringer IBellRinger) bool { var returns bool _jsii_.Invoke( @@ -5020,7 +5020,7 @@ func (c *consumerCanRingBell_jsiiProxy) ImplementedByPublicClass(ringer IBellRin // If the parameter is a concrete class instead of an interface. // // Return whether the bell was rung. -func (c *consumerCanRingBell_jsiiProxy) WhenTypedAsClass(ringer IConcreteBellRinger) bool { +func (c *jsiiProxy_ConsumerCanRingBell) WhenTypedAsClass(ringer IConcreteBellRinger) bool { var returns bool _jsii_.Invoke( @@ -5039,27 +5039,27 @@ type ConsumersOfThisCrazyTypeSystem interface { } // The jsii proxy struct for ConsumersOfThisCrazyTypeSystem -type consumersOfThisCrazyTypeSystem_jsiiProxy struct { +type jsiiProxy_ConsumersOfThisCrazyTypeSystem struct { _ byte // padding } func NewConsumersOfThisCrazyTypeSystem() ConsumersOfThisCrazyTypeSystem { _init_.Initialize() - c := consumersOfThisCrazyTypeSystem_jsiiProxy{} + j := jsiiProxy_ConsumersOfThisCrazyTypeSystem{} _jsii_.Create( "jsii-calc.ConsumersOfThisCrazyTypeSystem", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *consumersOfThisCrazyTypeSystem_jsiiProxy) ConsumeAnotherPublicInterface(obj IAnotherPublicInterface) string { +func (c *jsiiProxy_ConsumersOfThisCrazyTypeSystem) ConsumeAnotherPublicInterface(obj IAnotherPublicInterface) string { var returns string _jsii_.Invoke( @@ -5072,7 +5072,7 @@ func (c *consumersOfThisCrazyTypeSystem_jsiiProxy) ConsumeAnotherPublicInterface return returns } -func (c *consumersOfThisCrazyTypeSystem_jsiiProxy) ConsumeNonInternalInterface(obj INonInternalInterface) interface{} { +func (c *jsiiProxy_ConsumersOfThisCrazyTypeSystem) ConsumeNonInternalInterface(obj INonInternalInterface) interface{} { var returns interface{} _jsii_.Invoke( @@ -5093,27 +5093,27 @@ type DataRenderer interface { } // The jsii proxy struct for DataRenderer -type dataRenderer_jsiiProxy struct { +type jsiiProxy_DataRenderer struct { _ byte // padding } func NewDataRenderer() DataRenderer { _init_.Initialize() - d := dataRenderer_jsiiProxy{} + j := jsiiProxy_DataRenderer{} _jsii_.Create( "jsii-calc.DataRenderer", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *dataRenderer_jsiiProxy) Render(data scopejsiicalclib.MyFirstStruct) string { +func (d *jsiiProxy_DataRenderer) Render(data scopejsiicalclib.MyFirstStruct) string { var returns string _jsii_.Invoke( @@ -5126,7 +5126,7 @@ func (d *dataRenderer_jsiiProxy) Render(data scopejsiicalclib.MyFirstStruct) str return returns } -func (d *dataRenderer_jsiiProxy) RenderArbitrary(data map[string]interface{}) string { +func (d *jsiiProxy_DataRenderer) RenderArbitrary(data map[string]interface{}) string { var returns string _jsii_.Invoke( @@ -5139,7 +5139,7 @@ func (d *dataRenderer_jsiiProxy) RenderArbitrary(data map[string]interface{}) st return returns } -func (d *dataRenderer_jsiiProxy) RenderMap(map_ map[string]interface{}) string { +func (d *jsiiProxy_DataRenderer) RenderMap(map_ map[string]interface{}) string { var returns string _jsii_.Invoke( @@ -5160,27 +5160,27 @@ type Default interface { } // The jsii proxy struct for Default -type default_jsiiProxy struct { +type jsiiProxy_Default struct { _ byte // padding } func NewDefault() Default { _init_.Initialize() - d := default_jsiiProxy{} + j := jsiiProxy_Default{} _jsii_.Create( "jsii-calc.Default", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *default_jsiiProxy) PleaseCompile() { +func (d *jsiiProxy_Default) PleaseCompile() { _jsii_.InvokeVoid( d, "pleaseCompile", @@ -5195,34 +5195,34 @@ type DefaultedConstructorArgument interface { } // The jsii proxy struct for DefaultedConstructorArgument -type defaultedConstructorArgument_jsiiProxy struct { +type jsiiProxy_DefaultedConstructorArgument struct { _ byte // padding } -func (d *defaultedConstructorArgument_jsiiProxy) Arg1() float64 { +func (j *jsiiProxy_DefaultedConstructorArgument) Arg1() float64 { var returns float64 _jsii_.Get( - d, + j, "arg1", &returns, ) return returns } -func (d *defaultedConstructorArgument_jsiiProxy) Arg2() string { +func (j *jsiiProxy_DefaultedConstructorArgument) Arg2() string { var returns string _jsii_.Get( - d, + j, "arg2", &returns, ) return returns } -func (d *defaultedConstructorArgument_jsiiProxy) Arg3() string { +func (j *jsiiProxy_DefaultedConstructorArgument) Arg3() string { var returns string _jsii_.Get( - d, + j, "arg3", &returns, ) @@ -5233,17 +5233,17 @@ func (d *defaultedConstructorArgument_jsiiProxy) Arg3() string { func NewDefaultedConstructorArgument(arg1 float64, arg2 string, arg3 string) DefaultedConstructorArgument { _init_.Initialize() - d := defaultedConstructorArgument_jsiiProxy{} + j := jsiiProxy_DefaultedConstructorArgument{} _jsii_.Create( "jsii-calc.DefaultedConstructorArgument", []interface{}{arg1, arg2, arg3}, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } // 1. @@ -5254,24 +5254,24 @@ type Demonstrate982 interface { } // The jsii proxy struct for Demonstrate982 -type demonstrate982_jsiiProxy struct { +type jsiiProxy_Demonstrate982 struct { _ byte // padding } func NewDemonstrate982() Demonstrate982 { _init_.Initialize() - d := demonstrate982_jsiiProxy{} + j := jsiiProxy_Demonstrate982{} _jsii_.Create( "jsii-calc.Demonstrate982", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } // It's dangerous to go alone! @@ -5315,24 +5315,24 @@ type DeprecatedClass interface { } // The jsii proxy struct for DeprecatedClass -type deprecatedClass_jsiiProxy struct { +type jsiiProxy_DeprecatedClass struct { _ byte // padding } -func (d *deprecatedClass_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_DeprecatedClass) MutableProperty() float64 { var returns float64 _jsii_.Get( - d, + j, "mutableProperty", &returns, ) return returns } -func (d *deprecatedClass_jsiiProxy) ReadonlyProperty() string { +func (j *jsiiProxy_DeprecatedClass) ReadonlyProperty() string { var returns string _jsii_.Get( - d, + j, "readonlyProperty", &returns, ) @@ -5344,29 +5344,29 @@ func (d *deprecatedClass_jsiiProxy) ReadonlyProperty() string { func NewDeprecatedClass(readonlyString string, mutableNumber float64) DeprecatedClass { _init_.Initialize() - d := deprecatedClass_jsiiProxy{} + j := jsiiProxy_DeprecatedClass{} _jsii_.Create( "jsii-calc.DeprecatedClass", []interface{}{readonlyString, mutableNumber}, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *deprecatedClass_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_DeprecatedClass) SetMutableProperty(val float64) { _jsii_.Set( - d, + j, "mutableProperty", val, ) } // Deprecated: it was a bad idea -func (d *deprecatedClass_jsiiProxy) Method() { +func (d *jsiiProxy_DeprecatedClass) Method() { _jsii_.InvokeVoid( d, "method", @@ -5508,7 +5508,7 @@ type DisappointingCollectionSource interface { } // The jsii proxy struct for DisappointingCollectionSource -type disappointingCollectionSource_jsiiProxy struct { +type jsiiProxy_DisappointingCollectionSource struct { _ byte // padding } @@ -5541,27 +5541,27 @@ type DoNotOverridePrivates interface { } // The jsii proxy struct for DoNotOverridePrivates -type doNotOverridePrivates_jsiiProxy struct { +type jsiiProxy_DoNotOverridePrivates struct { _ byte // padding } func NewDoNotOverridePrivates() DoNotOverridePrivates { _init_.Initialize() - d := doNotOverridePrivates_jsiiProxy{} + j := jsiiProxy_DoNotOverridePrivates{} _jsii_.Create( "jsii-calc.DoNotOverridePrivates", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *doNotOverridePrivates_jsiiProxy) ChangePrivatePropertyValue(newValue string) { +func (d *jsiiProxy_DoNotOverridePrivates) ChangePrivatePropertyValue(newValue string) { _jsii_.InvokeVoid( d, "changePrivatePropertyValue", @@ -5569,7 +5569,7 @@ func (d *doNotOverridePrivates_jsiiProxy) ChangePrivatePropertyValue(newValue st ) } -func (d *doNotOverridePrivates_jsiiProxy) PrivateMethodValue() string { +func (d *jsiiProxy_DoNotOverridePrivates) PrivateMethodValue() string { var returns string _jsii_.Invoke( @@ -5582,7 +5582,7 @@ func (d *doNotOverridePrivates_jsiiProxy) PrivateMethodValue() string { return returns } -func (d *doNotOverridePrivates_jsiiProxy) PrivatePropertyValue() string { +func (d *jsiiProxy_DoNotOverridePrivates) PrivatePropertyValue() string { var returns string _jsii_.Invoke( @@ -5601,27 +5601,27 @@ type DoNotRecognizeAnyAsOptional interface { } // The jsii proxy struct for DoNotRecognizeAnyAsOptional -type doNotRecognizeAnyAsOptional_jsiiProxy struct { +type jsiiProxy_DoNotRecognizeAnyAsOptional struct { _ byte // padding } func NewDoNotRecognizeAnyAsOptional() DoNotRecognizeAnyAsOptional { _init_.Initialize() - d := doNotRecognizeAnyAsOptional_jsiiProxy{} + j := jsiiProxy_DoNotRecognizeAnyAsOptional{} _jsii_.Create( "jsii-calc.DoNotRecognizeAnyAsOptional", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *doNotRecognizeAnyAsOptional_jsiiProxy) Method(_requiredAny interface{}, _optionalAny interface{}, _optionalString string) { +func (d *jsiiProxy_DoNotRecognizeAnyAsOptional) Method(_requiredAny interface{}, _optionalAny interface{}, _optionalString string) { _jsii_.InvokeVoid( d, "method", @@ -5644,24 +5644,24 @@ type DocumentedClass interface { } // The jsii proxy struct for DocumentedClass -type documentedClass_jsiiProxy struct { +type jsiiProxy_DocumentedClass struct { _ byte // padding } func NewDocumentedClass() DocumentedClass { _init_.Initialize() - d := documentedClass_jsiiProxy{} + j := jsiiProxy_DocumentedClass{} _jsii_.Create( "jsii-calc.DocumentedClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } // Greet the indicated person. @@ -5670,7 +5670,7 @@ func NewDocumentedClass() DocumentedClass { // // Returns: A number that everyone knows very well and represents the answer // to the ultimate question -func (d *documentedClass_jsiiProxy) Greet(greetee Greetee) float64 { +func (d *jsiiProxy_DocumentedClass) Greet(greetee Greetee) float64 { var returns float64 _jsii_.Invoke( @@ -5685,7 +5685,7 @@ func (d *documentedClass_jsiiProxy) Greet(greetee Greetee) float64 { // Say ¡Hola! // Experimental. -func (d *documentedClass_jsiiProxy) Hola() { +func (d *jsiiProxy_DocumentedClass) Hola() { _jsii_.InvokeVoid( d, "hola", @@ -5698,27 +5698,27 @@ type DontComplainAboutVariadicAfterOptional interface { } // The jsii proxy struct for DontComplainAboutVariadicAfterOptional -type dontComplainAboutVariadicAfterOptional_jsiiProxy struct { +type jsiiProxy_DontComplainAboutVariadicAfterOptional struct { _ byte // padding } func NewDontComplainAboutVariadicAfterOptional() DontComplainAboutVariadicAfterOptional { _init_.Initialize() - d := dontComplainAboutVariadicAfterOptional_jsiiProxy{} + j := jsiiProxy_DontComplainAboutVariadicAfterOptional{} _jsii_.Create( "jsii-calc.DontComplainAboutVariadicAfterOptional", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *dontComplainAboutVariadicAfterOptional_jsiiProxy) OptionalAndVariadic(optional string, things string) string { +func (d *jsiiProxy_DontComplainAboutVariadicAfterOptional) OptionalAndVariadic(optional string, things string) string { var returns string _jsii_.Invoke( @@ -5738,28 +5738,28 @@ type DoubleTrouble interface { } // The jsii proxy struct for DoubleTrouble -type doubleTrouble_jsiiProxy struct { - iFriendlyRandomGenerator_jsiiProxy // implements jsii-calc.IFriendlyRandomGenerator +type jsiiProxy_DoubleTrouble struct { + jsiiProxy_IFriendlyRandomGenerator // implements jsii-calc.IFriendlyRandomGenerator } func NewDoubleTrouble() DoubleTrouble { _init_.Initialize() - d := doubleTrouble_jsiiProxy{} + j := jsiiProxy_DoubleTrouble{} _jsii_.Create( "jsii-calc.DoubleTrouble", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IFriendlyRandomGenerator"}, nil, // no overrides - &d, + &j, ) - return &d + return &j } // (deprecated) Say hello! -func (d *doubleTrouble_jsiiProxy) Hello() string { +func (d *jsiiProxy_DoubleTrouble) Hello() string { var returns string _jsii_.Invoke( @@ -5773,7 +5773,7 @@ func (d *doubleTrouble_jsiiProxy) Hello() string { } // Returns another random number. -func (d *doubleTrouble_jsiiProxy) Next() float64 { +func (d *jsiiProxy_DoubleTrouble) Next() float64 { var returns float64 _jsii_.Invoke( @@ -5795,24 +5795,24 @@ type DynamicPropertyBearer interface { } // The jsii proxy struct for DynamicPropertyBearer -type dynamicPropertyBearer_jsiiProxy struct { +type jsiiProxy_DynamicPropertyBearer struct { _ byte // padding } -func (d *dynamicPropertyBearer_jsiiProxy) DynamicProperty() string { +func (j *jsiiProxy_DynamicPropertyBearer) DynamicProperty() string { var returns string _jsii_.Get( - d, + j, "dynamicProperty", &returns, ) return returns } -func (d *dynamicPropertyBearer_jsiiProxy) ValueStore() string { +func (j *jsiiProxy_DynamicPropertyBearer) ValueStore() string { var returns string _jsii_.Get( - d, + j, "valueStore", &returns, ) @@ -5823,30 +5823,30 @@ func (d *dynamicPropertyBearer_jsiiProxy) ValueStore() string { func NewDynamicPropertyBearer(valueStore string) DynamicPropertyBearer { _init_.Initialize() - d := dynamicPropertyBearer_jsiiProxy{} + j := jsiiProxy_DynamicPropertyBearer{} _jsii_.Create( "jsii-calc.DynamicPropertyBearer", []interface{}{valueStore}, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } -func (d *dynamicPropertyBearer_jsiiProxy) SetDynamicProperty(val string) { +func (j *jsiiProxy_DynamicPropertyBearer) SetDynamicProperty(val string) { _jsii_.Set( - d, + j, "dynamicProperty", val, ) } -func (d *dynamicPropertyBearer_jsiiProxy) SetValueStore(val string) { +func (j *jsiiProxy_DynamicPropertyBearer) SetValueStore(val string) { _jsii_.Set( - d, + j, "valueStore", val, ) @@ -5859,14 +5859,14 @@ type DynamicPropertyBearerChild interface { } // The jsii proxy struct for DynamicPropertyBearerChild -type dynamicPropertyBearerChild_jsiiProxy struct { - dynamicPropertyBearer_jsiiProxy // extends jsii-calc.DynamicPropertyBearer +type jsiiProxy_DynamicPropertyBearerChild struct { + jsiiProxy_DynamicPropertyBearer // extends jsii-calc.DynamicPropertyBearer } -func (d *dynamicPropertyBearerChild_jsiiProxy) OriginalValue() string { +func (j *jsiiProxy_DynamicPropertyBearerChild) OriginalValue() string { var returns string _jsii_.Get( - d, + j, "originalValue", &returns, ) @@ -5877,23 +5877,23 @@ func (d *dynamicPropertyBearerChild_jsiiProxy) OriginalValue() string { func NewDynamicPropertyBearerChild(originalValue string) DynamicPropertyBearerChild { _init_.Initialize() - d := dynamicPropertyBearerChild_jsiiProxy{} + j := jsiiProxy_DynamicPropertyBearerChild{} _jsii_.Create( "jsii-calc.DynamicPropertyBearerChild", []interface{}{originalValue}, []_jsii_.FQN{}, nil, // no overrides - &d, + &j, ) - return &d + return &j } // Sets \`this.dynamicProperty\` to the new value, and returns the old value. // // Returns: the old value that was set. -func (d *dynamicPropertyBearerChild_jsiiProxy) OverrideValue(newValue string) string { +func (d *jsiiProxy_DynamicPropertyBearerChild) OverrideValue(newValue string) string { var returns string _jsii_.Invoke( @@ -5913,7 +5913,7 @@ type Entropy interface { } // The jsii proxy struct for Entropy -type entropy_jsiiProxy struct { +type jsiiProxy_Entropy struct { _ byte // padding } @@ -5921,23 +5921,23 @@ type entropy_jsiiProxy struct { func NewEntropy(clock IWallClock) Entropy { _init_.Initialize() - e := entropy_jsiiProxy{} + j := jsiiProxy_Entropy{} _jsii_.Create( "jsii-calc.Entropy", []interface{}{clock}, []_jsii_.FQN{}, nil, // no overrides - &e, + &j, ) - return &e + return &j } // Increases entropy by consuming time from the clock (yes, this is a long shot, please don't judge). // // Returns: the time from the \`WallClock\`. -func (e *entropy_jsiiProxy) Increase() string { +func (e *jsiiProxy_Entropy) Increase() string { var returns string _jsii_.Invoke( @@ -5953,7 +5953,7 @@ func (e *entropy_jsiiProxy) Increase() string { // Implement this method such that it returns \`word\`. // // Returns: \`word\`. -func (e *entropy_jsiiProxy) Repeat(word string) string { +func (e *jsiiProxy_Entropy) Repeat(word string) string { var returns string _jsii_.Invoke( @@ -5970,7 +5970,7 @@ type EnumDispenser interface { } // The jsii proxy struct for EnumDispenser -type enumDispenser_jsiiProxy struct { +type jsiiProxy_EnumDispenser struct { _ byte // padding } @@ -6008,24 +6008,24 @@ type EraseUndefinedHashValues interface { } // The jsii proxy struct for EraseUndefinedHashValues -type eraseUndefinedHashValues_jsiiProxy struct { +type jsiiProxy_EraseUndefinedHashValues struct { _ byte // padding } func NewEraseUndefinedHashValues() EraseUndefinedHashValues { _init_.Initialize() - e := eraseUndefinedHashValues_jsiiProxy{} + j := jsiiProxy_EraseUndefinedHashValues{} _jsii_.Create( "jsii-calc.EraseUndefinedHashValues", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &e, + &j, ) - return &e + return &j } // Returns \`true\` if \`key\` is defined in \`opts\`. @@ -6093,24 +6093,24 @@ type ExperimentalClass interface { } // The jsii proxy struct for ExperimentalClass -type experimentalClass_jsiiProxy struct { +type jsiiProxy_ExperimentalClass struct { _ byte // padding } -func (e *experimentalClass_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_ExperimentalClass) MutableProperty() float64 { var returns float64 _jsii_.Get( - e, + j, "mutableProperty", &returns, ) return returns } -func (e *experimentalClass_jsiiProxy) ReadonlyProperty() string { +func (j *jsiiProxy_ExperimentalClass) ReadonlyProperty() string { var returns string _jsii_.Get( - e, + j, "readonlyProperty", &returns, ) @@ -6122,29 +6122,29 @@ func (e *experimentalClass_jsiiProxy) ReadonlyProperty() string { func NewExperimentalClass(readonlyString string, mutableNumber float64) ExperimentalClass { _init_.Initialize() - e := experimentalClass_jsiiProxy{} + j := jsiiProxy_ExperimentalClass{} _jsii_.Create( "jsii-calc.ExperimentalClass", []interface{}{readonlyString, mutableNumber}, []_jsii_.FQN{}, nil, // no overrides - &e, + &j, ) - return &e + return &j } -func (e *experimentalClass_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_ExperimentalClass) SetMutableProperty(val float64) { _jsii_.Set( - e, + j, "mutableProperty", val, ) } // Experimental. -func (e *experimentalClass_jsiiProxy) Method() { +func (e *jsiiProxy_ExperimentalClass) Method() { _jsii_.InvokeVoid( e, "method", @@ -6171,14 +6171,14 @@ type ExportedBaseClass interface { } // The jsii proxy struct for ExportedBaseClass -type exportedBaseClass_jsiiProxy struct { +type jsiiProxy_ExportedBaseClass struct { _ byte // padding } -func (e *exportedBaseClass_jsiiProxy) Success() bool { +func (j *jsiiProxy_ExportedBaseClass) Success() bool { var returns bool _jsii_.Get( - e, + j, "success", &returns, ) @@ -6189,17 +6189,17 @@ func (e *exportedBaseClass_jsiiProxy) Success() bool { func NewExportedBaseClass(success bool) ExportedBaseClass { _init_.Initialize() - e := exportedBaseClass_jsiiProxy{} + j := jsiiProxy_ExportedBaseClass{} _jsii_.Create( "jsii-calc.ExportedBaseClass", []interface{}{success}, []_jsii_.FQN{}, nil, // no overrides - &e, + &j, ) - return &e + return &j } type ExtendsInternalInterface struct { @@ -6215,24 +6215,24 @@ type ExternalClass interface { } // The jsii proxy struct for ExternalClass -type externalClass_jsiiProxy struct { +type jsiiProxy_ExternalClass struct { _ byte // padding } -func (e *externalClass_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_ExternalClass) MutableProperty() float64 { var returns float64 _jsii_.Get( - e, + j, "mutableProperty", &returns, ) return returns } -func (e *externalClass_jsiiProxy) ReadonlyProperty() string { +func (j *jsiiProxy_ExternalClass) ReadonlyProperty() string { var returns string _jsii_.Get( - e, + j, "readonlyProperty", &returns, ) @@ -6243,28 +6243,28 @@ func (e *externalClass_jsiiProxy) ReadonlyProperty() string { func NewExternalClass(readonlyString string, mutableNumber float64) ExternalClass { _init_.Initialize() - e := externalClass_jsiiProxy{} + j := jsiiProxy_ExternalClass{} _jsii_.Create( "jsii-calc.ExternalClass", []interface{}{readonlyString, mutableNumber}, []_jsii_.FQN{}, nil, // no overrides - &e, + &j, ) - return &e + return &j } -func (e *externalClass_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_ExternalClass) SetMutableProperty(val float64) { _jsii_.Set( - e, + j, "mutableProperty", val, ) } -func (e *externalClass_jsiiProxy) Method() { +func (e *jsiiProxy_ExternalClass) Method() { _jsii_.InvokeVoid( e, "method", @@ -6291,14 +6291,14 @@ type GiveMeStructs interface { } // The jsii proxy struct for GiveMeStructs -type giveMeStructs_jsiiProxy struct { +type jsiiProxy_GiveMeStructs struct { _ byte // padding } -func (g *giveMeStructs_jsiiProxy) StructLiteral() scopejsiicalclib.StructWithOnlyOptionals { +func (j *jsiiProxy_GiveMeStructs) StructLiteral() scopejsiicalclib.StructWithOnlyOptionals { var returns scopejsiicalclib.StructWithOnlyOptionals _jsii_.Get( - g, + j, "structLiteral", &returns, ) @@ -6309,21 +6309,21 @@ func (g *giveMeStructs_jsiiProxy) StructLiteral() scopejsiicalclib.StructWithOnl func NewGiveMeStructs() GiveMeStructs { _init_.Initialize() - g := giveMeStructs_jsiiProxy{} + j := jsiiProxy_GiveMeStructs{} _jsii_.Create( "jsii-calc.GiveMeStructs", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &g, + &j, ) - return &g + return &j } // Accepts a struct of type DerivedStruct and returns a struct of type FirstStruct. -func (g *giveMeStructs_jsiiProxy) DerivedToFirst(derived DerivedStruct) scopejsiicalclib.MyFirstStruct { +func (g *jsiiProxy_GiveMeStructs) DerivedToFirst(derived DerivedStruct) scopejsiicalclib.MyFirstStruct { var returns scopejsiicalclib.MyFirstStruct _jsii_.Invoke( @@ -6337,7 +6337,7 @@ func (g *giveMeStructs_jsiiProxy) DerivedToFirst(derived DerivedStruct) scopejsi } // Returns the boolean from a DerivedStruct struct. -func (g *giveMeStructs_jsiiProxy) ReadDerivedNonPrimitive(derived DerivedStruct) DoubleTrouble { +func (g *jsiiProxy_GiveMeStructs) ReadDerivedNonPrimitive(derived DerivedStruct) DoubleTrouble { var returns DoubleTrouble _jsii_.Invoke( @@ -6351,7 +6351,7 @@ func (g *giveMeStructs_jsiiProxy) ReadDerivedNonPrimitive(derived DerivedStruct) } // Returns the "anumber" from a MyFirstStruct struct; -func (g *giveMeStructs_jsiiProxy) ReadFirstNumber(first scopejsiicalclib.MyFirstStruct) float64 { +func (g *jsiiProxy_GiveMeStructs) ReadFirstNumber(first scopejsiicalclib.MyFirstStruct) float64 { var returns float64 _jsii_.Invoke( @@ -6375,27 +6375,27 @@ type GreetingAugmenter interface { } // The jsii proxy struct for GreetingAugmenter -type greetingAugmenter_jsiiProxy struct { +type jsiiProxy_GreetingAugmenter struct { _ byte // padding } func NewGreetingAugmenter() GreetingAugmenter { _init_.Initialize() - g := greetingAugmenter_jsiiProxy{} + j := jsiiProxy_GreetingAugmenter{} _jsii_.Create( "jsii-calc.GreetingAugmenter", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &g, + &j, ) - return &g + return &j } -func (g *greetingAugmenter_jsiiProxy) BetterGreeting(friendly scopejsiicalclib.IFriendly) string { +func (g *jsiiProxy_GreetingAugmenter) BetterGreeting(friendly scopejsiicalclib.IFriendly) string { var returns string _jsii_.Invoke( @@ -6415,11 +6415,11 @@ type IAnonymousImplementationProvider interface { } // The jsii proxy for IAnonymousImplementationProvider -type iAnonymousImplementationProvider_jsiiProxy struct { +type jsiiProxy_IAnonymousImplementationProvider struct { _ byte // padding } -func (i *iAnonymousImplementationProvider_jsiiProxy) ProvideAsClass() Implementation { +func (i *jsiiProxy_IAnonymousImplementationProvider) ProvideAsClass() Implementation { var returns Implementation _jsii_.Invoke( @@ -6432,7 +6432,7 @@ func (i *iAnonymousImplementationProvider_jsiiProxy) ProvideAsClass() Implementa return returns } -func (i *iAnonymousImplementationProvider_jsiiProxy) ProvideAsInterface() IAnonymouslyImplementMe { +func (i *jsiiProxy_IAnonymousImplementationProvider) ProvideAsInterface() IAnonymouslyImplementMe { var returns IAnonymouslyImplementMe _jsii_.Invoke( @@ -6451,11 +6451,11 @@ type IAnonymouslyImplementMe interface { } // The jsii proxy for IAnonymouslyImplementMe -type iAnonymouslyImplementMe_jsiiProxy struct { +type jsiiProxy_IAnonymouslyImplementMe struct { _ byte // padding } -func (i *iAnonymouslyImplementMe_jsiiProxy) Verb() string { +func (i *jsiiProxy_IAnonymouslyImplementMe) Verb() string { var returns string _jsii_.Invoke( @@ -6468,10 +6468,10 @@ func (i *iAnonymouslyImplementMe_jsiiProxy) Verb() string { return returns } -func (i *iAnonymouslyImplementMe_jsiiProxy) Value() float64 { +func (j *jsiiProxy_IAnonymouslyImplementMe) Value() float64 { var returns float64 _jsii_.Get( - i, + j, "value", &returns, ) @@ -6483,23 +6483,23 @@ type IAnotherPublicInterface interface { } // The jsii proxy for IAnotherPublicInterface -type iAnotherPublicInterface_jsiiProxy struct { +type jsiiProxy_IAnotherPublicInterface struct { _ byte // padding } -func (i *iAnotherPublicInterface_jsiiProxy) A() string { +func (j *jsiiProxy_IAnotherPublicInterface) A() string { var returns string _jsii_.Get( - i, + j, "a", &returns, ) return returns } -func (i *iAnotherPublicInterface_jsiiProxy) SetA(val string) { +func (j *jsiiProxy_IAnotherPublicInterface) SetA(val string) { _jsii_.Set( - i, + j, "a", val, ) @@ -6510,11 +6510,11 @@ type IBell interface { } // The jsii proxy for IBell -type iBell_jsiiProxy struct { +type jsiiProxy_IBell struct { _ byte // padding } -func (i *iBell_jsiiProxy) Ring() { +func (i *jsiiProxy_IBell) Ring() { _jsii_.InvokeVoid( i, "ring", @@ -6528,11 +6528,11 @@ type IBellRinger interface { } // The jsii proxy for IBellRinger -type iBellRinger_jsiiProxy struct { +type jsiiProxy_IBellRinger struct { _ byte // padding } -func (i *iBellRinger_jsiiProxy) YourTurn(bell IBell) { +func (i *jsiiProxy_IBellRinger) YourTurn(bell IBell) { _jsii_.InvokeVoid( i, "yourTurn", @@ -6546,11 +6546,11 @@ type IConcreteBellRinger interface { } // The jsii proxy for IConcreteBellRinger -type iConcreteBellRinger_jsiiProxy struct { +type jsiiProxy_IConcreteBellRinger struct { _ byte // padding } -func (i *iConcreteBellRinger_jsiiProxy) YourTurn(bell Bell) { +func (i *jsiiProxy_IConcreteBellRinger) YourTurn(bell Bell) { _jsii_.InvokeVoid( i, "yourTurn", @@ -6567,11 +6567,11 @@ type IDeprecatedInterface interface { } // The jsii proxy for IDeprecatedInterface -type iDeprecatedInterface_jsiiProxy struct { +type jsiiProxy_IDeprecatedInterface struct { _ byte // padding } -func (i *iDeprecatedInterface_jsiiProxy) Method() { +func (i *jsiiProxy_IDeprecatedInterface) Method() { _jsii_.InvokeVoid( i, "method", @@ -6579,19 +6579,19 @@ func (i *iDeprecatedInterface_jsiiProxy) Method() { ) } -func (i *iDeprecatedInterface_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_IDeprecatedInterface) MutableProperty() float64 { var returns float64 _jsii_.Get( - i, + j, "mutableProperty", &returns, ) return returns } -func (i *iDeprecatedInterface_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_IDeprecatedInterface) SetMutableProperty(val float64) { _jsii_.Set( - i, + j, "mutableProperty", val, ) @@ -6606,11 +6606,11 @@ type IExperimentalInterface interface { } // The jsii proxy for IExperimentalInterface -type iExperimentalInterface_jsiiProxy struct { +type jsiiProxy_IExperimentalInterface struct { _ byte // padding } -func (i *iExperimentalInterface_jsiiProxy) Method() { +func (i *jsiiProxy_IExperimentalInterface) Method() { _jsii_.InvokeVoid( i, "method", @@ -6618,19 +6618,19 @@ func (i *iExperimentalInterface_jsiiProxy) Method() { ) } -func (i *iExperimentalInterface_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_IExperimentalInterface) MutableProperty() float64 { var returns float64 _jsii_.Get( - i, + j, "mutableProperty", &returns, ) return returns } -func (i *iExperimentalInterface_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_IExperimentalInterface) SetMutableProperty(val float64) { _jsii_.Set( - i, + j, "mutableProperty", val, ) @@ -6642,33 +6642,33 @@ type IExtendsPrivateInterface interface { } // The jsii proxy for IExtendsPrivateInterface -type iExtendsPrivateInterface_jsiiProxy struct { +type jsiiProxy_IExtendsPrivateInterface struct { _ byte // padding } -func (i *iExtendsPrivateInterface_jsiiProxy) MoreThings() []string { +func (j *jsiiProxy_IExtendsPrivateInterface) MoreThings() []string { var returns []string _jsii_.Get( - i, + j, "moreThings", &returns, ) return returns } -func (i *iExtendsPrivateInterface_jsiiProxy) Private() string { +func (j *jsiiProxy_IExtendsPrivateInterface) Private() string { var returns string _jsii_.Get( - i, + j, "private", &returns, ) return returns } -func (i *iExtendsPrivateInterface_jsiiProxy) SetPrivate(val string) { +func (j *jsiiProxy_IExtendsPrivateInterface) SetPrivate(val string) { _jsii_.Set( - i, + j, "private", val, ) @@ -6680,11 +6680,11 @@ type IExternalInterface interface { } // The jsii proxy for IExternalInterface -type iExternalInterface_jsiiProxy struct { +type jsiiProxy_IExternalInterface struct { _ byte // padding } -func (i *iExternalInterface_jsiiProxy) Method() { +func (i *jsiiProxy_IExternalInterface) Method() { _jsii_.InvokeVoid( i, "method", @@ -6692,19 +6692,19 @@ func (i *iExternalInterface_jsiiProxy) Method() { ) } -func (i *iExternalInterface_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_IExternalInterface) MutableProperty() float64 { var returns float64 _jsii_.Get( - i, + j, "mutableProperty", &returns, ) return returns } -func (i *iExternalInterface_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_IExternalInterface) SetMutableProperty(val float64) { _jsii_.Set( - i, + j, "mutableProperty", val, ) @@ -6722,11 +6722,11 @@ type IFriendlier interface { } // The jsii proxy for IFriendlier -type iFriendlier_jsiiProxy struct { +type jsiiProxy_IFriendlier struct { scopejsiicalclib.IFriendly // extends @scope/jsii-calc-lib.IFriendly } -func (i *iFriendlier_jsiiProxy) Farewell() string { +func (i *jsiiProxy_IFriendlier) Farewell() string { var returns string _jsii_.Invoke( @@ -6739,7 +6739,7 @@ func (i *iFriendlier_jsiiProxy) Farewell() string { return returns } -func (i *iFriendlier_jsiiProxy) Goodbye() string { +func (i *jsiiProxy_IFriendlier) Goodbye() string { var returns string _jsii_.Invoke( @@ -6758,12 +6758,12 @@ type IFriendlyRandomGenerator interface { } // The jsii proxy for IFriendlyRandomGenerator -type iFriendlyRandomGenerator_jsiiProxy struct { +type jsiiProxy_IFriendlyRandomGenerator struct { scopejsiicalclib.IFriendly // extends @scope/jsii-calc-lib.IFriendly - iRandomNumberGenerator_jsiiProxy // extends jsii-calc.IRandomNumberGenerator + jsiiProxy_IRandomNumberGenerator // extends jsii-calc.IRandomNumberGenerator } -func (i *iFriendlyRandomGenerator_jsiiProxy) Hello() string { +func (i *jsiiProxy_IFriendlyRandomGenerator) Hello() string { var returns string _jsii_.Invoke( @@ -6776,7 +6776,7 @@ func (i *iFriendlyRandomGenerator_jsiiProxy) Hello() string { return returns } -func (i *iFriendlyRandomGenerator_jsiiProxy) Next() float64 { +func (i *jsiiProxy_IFriendlyRandomGenerator) Next() float64 { var returns float64 _jsii_.Invoke( @@ -6795,14 +6795,14 @@ type IInterfaceImplementedByAbstractClass interface { } // The jsii proxy for IInterfaceImplementedByAbstractClass -type iInterfaceImplementedByAbstractClass_jsiiProxy struct { +type jsiiProxy_IInterfaceImplementedByAbstractClass struct { _ byte // padding } -func (i *iInterfaceImplementedByAbstractClass_jsiiProxy) PropFromInterface() string { +func (j *jsiiProxy_IInterfaceImplementedByAbstractClass) PropFromInterface() string { var returns string _jsii_.Get( - i, + j, "propFromInterface", &returns, ) @@ -6816,14 +6816,14 @@ type IInterfaceThatShouldNotBeADataType interface { } // The jsii proxy for IInterfaceThatShouldNotBeADataType -type iInterfaceThatShouldNotBeADataType_jsiiProxy struct { - iInterfaceWithMethods_jsiiProxy // extends jsii-calc.IInterfaceWithMethods +type jsiiProxy_IInterfaceThatShouldNotBeADataType struct { + jsiiProxy_IInterfaceWithMethods // extends jsii-calc.IInterfaceWithMethods } -func (i *iInterfaceThatShouldNotBeADataType_jsiiProxy) OtherValue() string { +func (j *jsiiProxy_IInterfaceThatShouldNotBeADataType) OtherValue() string { var returns string _jsii_.Get( - i, + j, "otherValue", &returns, ) @@ -6835,11 +6835,11 @@ type IInterfaceWithInternal interface { } // The jsii proxy for IInterfaceWithInternal -type iInterfaceWithInternal_jsiiProxy struct { +type jsiiProxy_IInterfaceWithInternal struct { _ byte // padding } -func (i *iInterfaceWithInternal_jsiiProxy) Visible() { +func (i *jsiiProxy_IInterfaceWithInternal) Visible() { _jsii_.InvokeVoid( i, "visible", @@ -6853,11 +6853,11 @@ type IInterfaceWithMethods interface { } // The jsii proxy for IInterfaceWithMethods -type iInterfaceWithMethods_jsiiProxy struct { +type jsiiProxy_IInterfaceWithMethods struct { _ byte // padding } -func (i *iInterfaceWithMethods_jsiiProxy) DoThings() { +func (i *jsiiProxy_IInterfaceWithMethods) DoThings() { _jsii_.InvokeVoid( i, "doThings", @@ -6865,10 +6865,10 @@ func (i *iInterfaceWithMethods_jsiiProxy) DoThings() { ) } -func (i *iInterfaceWithMethods_jsiiProxy) Value() string { +func (j *jsiiProxy_IInterfaceWithMethods) Value() string { var returns string _jsii_.Get( - i, + j, "value", &returns, ) @@ -6881,11 +6881,11 @@ type IInterfaceWithOptionalMethodArguments interface { } // The jsii proxy for IInterfaceWithOptionalMethodArguments -type iInterfaceWithOptionalMethodArguments_jsiiProxy struct { +type jsiiProxy_IInterfaceWithOptionalMethodArguments struct { _ byte // padding } -func (i *iInterfaceWithOptionalMethodArguments_jsiiProxy) Hello(arg1 string, arg2 float64) { +func (i *jsiiProxy_IInterfaceWithOptionalMethodArguments) Hello(arg1 string, arg2 float64) { _jsii_.InvokeVoid( i, "hello", @@ -6899,33 +6899,33 @@ type IInterfaceWithProperties interface { } // The jsii proxy for IInterfaceWithProperties -type iInterfaceWithProperties_jsiiProxy struct { +type jsiiProxy_IInterfaceWithProperties struct { _ byte // padding } -func (i *iInterfaceWithProperties_jsiiProxy) ReadOnlyString() string { +func (j *jsiiProxy_IInterfaceWithProperties) ReadOnlyString() string { var returns string _jsii_.Get( - i, + j, "readOnlyString", &returns, ) return returns } -func (i *iInterfaceWithProperties_jsiiProxy) ReadWriteString() string { +func (j *jsiiProxy_IInterfaceWithProperties) ReadWriteString() string { var returns string _jsii_.Get( - i, + j, "readWriteString", &returns, ) return returns } -func (i *iInterfaceWithProperties_jsiiProxy) SetReadWriteString(val string) { +func (j *jsiiProxy_IInterfaceWithProperties) SetReadWriteString(val string) { _jsii_.Set( - i, + j, "readWriteString", val, ) @@ -6937,23 +6937,23 @@ type IInterfaceWithPropertiesExtension interface { } // The jsii proxy for IInterfaceWithPropertiesExtension -type iInterfaceWithPropertiesExtension_jsiiProxy struct { - iInterfaceWithProperties_jsiiProxy // extends jsii-calc.IInterfaceWithProperties +type jsiiProxy_IInterfaceWithPropertiesExtension struct { + jsiiProxy_IInterfaceWithProperties // extends jsii-calc.IInterfaceWithProperties } -func (i *iInterfaceWithPropertiesExtension_jsiiProxy) Foo() float64 { +func (j *jsiiProxy_IInterfaceWithPropertiesExtension) Foo() float64 { var returns float64 _jsii_.Get( - i, + j, "foo", &returns, ) return returns } -func (i *iInterfaceWithPropertiesExtension_jsiiProxy) SetFoo(val float64) { +func (j *jsiiProxy_IInterfaceWithPropertiesExtension) SetFoo(val float64) { _jsii_.Set( - i, + j, "foo", val, ) @@ -6967,11 +6967,11 @@ type Ijsii417Derived interface { } // The jsii proxy for Ijsii417Derived -type ijsii417Derived_jsiiProxy struct { - ijsii417PublicBaseOfBase_jsiiProxy // extends jsii-calc.IJSII417PublicBaseOfBase +type jsiiProxy_Ijsii417Derived struct { + jsiiProxy_Ijsii417PublicBaseOfBase // extends jsii-calc.IJSII417PublicBaseOfBase } -func (i *ijsii417Derived_jsiiProxy) Bar() { +func (i *jsiiProxy_Ijsii417Derived) Bar() { _jsii_.InvokeVoid( i, "bar", @@ -6979,7 +6979,7 @@ func (i *ijsii417Derived_jsiiProxy) Bar() { ) } -func (i *ijsii417Derived_jsiiProxy) Baz() { +func (i *jsiiProxy_Ijsii417Derived) Baz() { _jsii_.InvokeVoid( i, "baz", @@ -6987,10 +6987,10 @@ func (i *ijsii417Derived_jsiiProxy) Baz() { ) } -func (i *ijsii417Derived_jsiiProxy) Property() string { +func (j *jsiiProxy_Ijsii417Derived) Property() string { var returns string _jsii_.Get( - i, + j, "property", &returns, ) @@ -7003,11 +7003,11 @@ type Ijsii417PublicBaseOfBase interface { } // The jsii proxy for Ijsii417PublicBaseOfBase -type ijsii417PublicBaseOfBase_jsiiProxy struct { +type jsiiProxy_Ijsii417PublicBaseOfBase struct { _ byte // padding } -func (i *ijsii417PublicBaseOfBase_jsiiProxy) Foo() { +func (i *jsiiProxy_Ijsii417PublicBaseOfBase) Foo() { _jsii_.InvokeVoid( i, "foo", @@ -7015,10 +7015,10 @@ func (i *ijsii417PublicBaseOfBase_jsiiProxy) Foo() { ) } -func (i *ijsii417PublicBaseOfBase_jsiiProxy) HasRoot() bool { +func (j *jsiiProxy_Ijsii417PublicBaseOfBase) HasRoot() bool { var returns bool _jsii_.Get( - i, + j, "hasRoot", &returns, ) @@ -7029,7 +7029,7 @@ type IJsii487External interface { } // The jsii proxy for IJsii487External -type iJsii487External_jsiiProxy struct { +type jsiiProxy_IJsii487External struct { _ byte // padding } @@ -7037,7 +7037,7 @@ type IJsii487External2 interface { } // The jsii proxy for IJsii487External2 -type iJsii487External2_jsiiProxy struct { +type jsiiProxy_IJsii487External2 struct { _ byte // padding } @@ -7045,7 +7045,7 @@ type IJsii496 interface { } // The jsii proxy for IJsii496 -type iJsii496_jsiiProxy struct { +type jsiiProxy_IJsii496 struct { _ byte // padding } @@ -7054,23 +7054,23 @@ type IMutableObjectLiteral interface { } // The jsii proxy for IMutableObjectLiteral -type iMutableObjectLiteral_jsiiProxy struct { +type jsiiProxy_IMutableObjectLiteral struct { _ byte // padding } -func (i *iMutableObjectLiteral_jsiiProxy) Value() string { +func (j *jsiiProxy_IMutableObjectLiteral) Value() string { var returns string _jsii_.Get( - i, + j, "value", &returns, ) return returns } -func (i *iMutableObjectLiteral_jsiiProxy) SetValue(val string) { +func (j *jsiiProxy_IMutableObjectLiteral) SetValue(val string) { _jsii_.Set( - i, + j, "value", val, ) @@ -7083,41 +7083,41 @@ type INonInternalInterface interface { } // The jsii proxy for INonInternalInterface -type iNonInternalInterface_jsiiProxy struct { - iAnotherPublicInterface_jsiiProxy // extends jsii-calc.IAnotherPublicInterface +type jsiiProxy_INonInternalInterface struct { + jsiiProxy_IAnotherPublicInterface // extends jsii-calc.IAnotherPublicInterface } -func (i *iNonInternalInterface_jsiiProxy) B() string { +func (j *jsiiProxy_INonInternalInterface) B() string { var returns string _jsii_.Get( - i, + j, "b", &returns, ) return returns } -func (i *iNonInternalInterface_jsiiProxy) SetB(val string) { +func (j *jsiiProxy_INonInternalInterface) SetB(val string) { _jsii_.Set( - i, + j, "b", val, ) } -func (i *iNonInternalInterface_jsiiProxy) C() string { +func (j *jsiiProxy_INonInternalInterface) C() string { var returns string _jsii_.Get( - i, + j, "c", &returns, ) return returns } -func (i *iNonInternalInterface_jsiiProxy) SetC(val string) { +func (j *jsiiProxy_INonInternalInterface) SetC(val string) { _jsii_.Set( - i, + j, "c", val, ) @@ -7130,11 +7130,11 @@ type IObjectWithProperty interface { } // The jsii proxy for IObjectWithProperty -type iObjectWithProperty_jsiiProxy struct { +type jsiiProxy_IObjectWithProperty struct { _ byte // padding } -func (i *iObjectWithProperty_jsiiProxy) WasSet() bool { +func (i *jsiiProxy_IObjectWithProperty) WasSet() bool { var returns bool _jsii_.Invoke( @@ -7147,19 +7147,19 @@ func (i *iObjectWithProperty_jsiiProxy) WasSet() bool { return returns } -func (i *iObjectWithProperty_jsiiProxy) Property() string { +func (j *jsiiProxy_IObjectWithProperty) Property() string { var returns string _jsii_.Get( - i, + j, "property", &returns, ) return returns } -func (i *iObjectWithProperty_jsiiProxy) SetProperty(val string) { +func (j *jsiiProxy_IObjectWithProperty) SetProperty(val string) { _jsii_.Set( - i, + j, "property", val, ) @@ -7171,11 +7171,11 @@ type IOptionalMethod interface { } // The jsii proxy for IOptionalMethod -type iOptionalMethod_jsiiProxy struct { +type jsiiProxy_IOptionalMethod struct { _ byte // padding } -func (i *iOptionalMethod_jsiiProxy) Optional() string { +func (i *jsiiProxy_IOptionalMethod) Optional() string { var returns string _jsii_.Invoke( @@ -7193,14 +7193,14 @@ type IPrivatelyImplemented interface { } // The jsii proxy for IPrivatelyImplemented -type iPrivatelyImplemented_jsiiProxy struct { +type jsiiProxy_IPrivatelyImplemented struct { _ byte // padding } -func (i *iPrivatelyImplemented_jsiiProxy) Success() bool { +func (j *jsiiProxy_IPrivatelyImplemented) Success() bool { var returns bool _jsii_.Get( - i, + j, "success", &returns, ) @@ -7212,11 +7212,11 @@ type IPublicInterface interface { } // The jsii proxy for IPublicInterface -type iPublicInterface_jsiiProxy struct { +type jsiiProxy_IPublicInterface struct { _ byte // padding } -func (i *iPublicInterface_jsiiProxy) Bye() string { +func (i *jsiiProxy_IPublicInterface) Bye() string { var returns string _jsii_.Invoke( @@ -7234,11 +7234,11 @@ type IPublicInterface2 interface { } // The jsii proxy for IPublicInterface2 -type iPublicInterface2_jsiiProxy struct { +type jsiiProxy_IPublicInterface2 struct { _ byte // padding } -func (i *iPublicInterface2_jsiiProxy) Ciao() string { +func (i *jsiiProxy_IPublicInterface2) Ciao() string { var returns string _jsii_.Invoke( @@ -7260,11 +7260,11 @@ type IRandomNumberGenerator interface { } // The jsii proxy for IRandomNumberGenerator -type iRandomNumberGenerator_jsiiProxy struct { +type jsiiProxy_IRandomNumberGenerator struct { _ byte // padding } -func (i *iRandomNumberGenerator_jsiiProxy) Next() float64 { +func (i *jsiiProxy_IRandomNumberGenerator) Next() float64 { var returns float64 _jsii_.Invoke( @@ -7283,14 +7283,14 @@ type IReturnJsii976 interface { } // The jsii proxy for IReturnJsii976 -type iReturnJsii976_jsiiProxy struct { +type jsiiProxy_IReturnJsii976 struct { _ byte // padding } -func (i *iReturnJsii976_jsiiProxy) Foo() float64 { +func (j *jsiiProxy_IReturnJsii976) Foo() float64 { var returns float64 _jsii_.Get( - i, + j, "foo", &returns, ) @@ -7303,11 +7303,11 @@ type IReturnsNumber interface { } // The jsii proxy for IReturnsNumber -type iReturnsNumber_jsiiProxy struct { +type jsiiProxy_IReturnsNumber struct { _ byte // padding } -func (i *iReturnsNumber_jsiiProxy) ObtainNumber() scopejsiicalclib.IDoublable { +func (i *jsiiProxy_IReturnsNumber) ObtainNumber() scopejsiicalclib.IDoublable { var returns scopejsiicalclib.IDoublable _jsii_.Invoke( @@ -7320,10 +7320,10 @@ func (i *iReturnsNumber_jsiiProxy) ObtainNumber() scopejsiicalclib.IDoublable { return returns } -func (i *iReturnsNumber_jsiiProxy) NumberProp() scopejsiicalclib.Number { +func (j *jsiiProxy_IReturnsNumber) NumberProp() scopejsiicalclib.Number { var returns scopejsiicalclib.Number _jsii_.Get( - i, + j, "numberProp", &returns, ) @@ -7336,11 +7336,11 @@ type IStableInterface interface { } // The jsii proxy for IStableInterface -type iStableInterface_jsiiProxy struct { +type jsiiProxy_IStableInterface struct { _ byte // padding } -func (i *iStableInterface_jsiiProxy) Method() { +func (i *jsiiProxy_IStableInterface) Method() { _jsii_.InvokeVoid( i, "method", @@ -7348,19 +7348,19 @@ func (i *iStableInterface_jsiiProxy) Method() { ) } -func (i *iStableInterface_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_IStableInterface) MutableProperty() float64 { var returns float64 _jsii_.Get( - i, + j, "mutableProperty", &returns, ) return returns } -func (i *iStableInterface_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_IStableInterface) SetMutableProperty(val float64) { _jsii_.Set( - i, + j, "mutableProperty", val, ) @@ -7372,11 +7372,11 @@ type IStructReturningDelegate interface { } // The jsii proxy for IStructReturningDelegate -type iStructReturningDelegate_jsiiProxy struct { +type jsiiProxy_IStructReturningDelegate struct { _ byte // padding } -func (i *iStructReturningDelegate_jsiiProxy) ReturnStruct() StructB { +func (i *jsiiProxy_IStructReturningDelegate) ReturnStruct() StructB { var returns StructB _jsii_.Invoke( @@ -7396,11 +7396,11 @@ type IWallClock interface { } // The jsii proxy for IWallClock -type iWallClock_jsiiProxy struct { +type jsiiProxy_IWallClock struct { _ byte // padding } -func (i *iWallClock_jsiiProxy) Iso8601Now() string { +func (i *jsiiProxy_IWallClock) Iso8601Now() string { var returns string _jsii_.Invoke( @@ -7419,14 +7419,14 @@ type ImplementInternalInterface interface { } // The jsii proxy struct for ImplementInternalInterface -type implementInternalInterface_jsiiProxy struct { +type jsiiProxy_ImplementInternalInterface struct { _ byte // padding } -func (i *implementInternalInterface_jsiiProxy) Prop() string { +func (j *jsiiProxy_ImplementInternalInterface) Prop() string { var returns string _jsii_.Get( - i, + j, "prop", &returns, ) @@ -7437,22 +7437,22 @@ func (i *implementInternalInterface_jsiiProxy) Prop() string { func NewImplementInternalInterface() ImplementInternalInterface { _init_.Initialize() - i := implementInternalInterface_jsiiProxy{} + j := jsiiProxy_ImplementInternalInterface{} _jsii_.Create( "jsii-calc.ImplementInternalInterface", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } -func (i *implementInternalInterface_jsiiProxy) SetProp(val string) { +func (j *jsiiProxy_ImplementInternalInterface) SetProp(val string) { _jsii_.Set( - i, + j, "prop", val, ) @@ -7463,14 +7463,14 @@ type Implementation interface { } // The jsii proxy struct for Implementation -type implementation_jsiiProxy struct { +type jsiiProxy_Implementation struct { _ byte // padding } -func (i *implementation_jsiiProxy) Value() float64 { +func (j *jsiiProxy_Implementation) Value() float64 { var returns float64 _jsii_.Get( - i, + j, "value", &returns, ) @@ -7481,17 +7481,17 @@ func (i *implementation_jsiiProxy) Value() float64 { func NewImplementation() Implementation { _init_.Initialize() - i := implementation_jsiiProxy{} + j := jsiiProxy_Implementation{} _jsii_.Create( "jsii-calc.Implementation", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } type ImplementsInterfaceWithInternal interface { @@ -7500,27 +7500,27 @@ type ImplementsInterfaceWithInternal interface { } // The jsii proxy struct for ImplementsInterfaceWithInternal -type implementsInterfaceWithInternal_jsiiProxy struct { - iInterfaceWithInternal_jsiiProxy // implements jsii-calc.IInterfaceWithInternal +type jsiiProxy_ImplementsInterfaceWithInternal struct { + jsiiProxy_IInterfaceWithInternal // implements jsii-calc.IInterfaceWithInternal } func NewImplementsInterfaceWithInternal() ImplementsInterfaceWithInternal { _init_.Initialize() - i := implementsInterfaceWithInternal_jsiiProxy{} + j := jsiiProxy_ImplementsInterfaceWithInternal{} _jsii_.Create( "jsii-calc.ImplementsInterfaceWithInternal", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IInterfaceWithInternal"}, nil, // no overrides - &i, + &j, ) - return &i + return &j } -func (i *implementsInterfaceWithInternal_jsiiProxy) Visible() { +func (i *jsiiProxy_ImplementsInterfaceWithInternal) Visible() { _jsii_.InvokeVoid( i, "visible", @@ -7533,24 +7533,24 @@ type ImplementsInterfaceWithInternalSubclass interface { } // The jsii proxy struct for ImplementsInterfaceWithInternalSubclass -type implementsInterfaceWithInternalSubclass_jsiiProxy struct { - implementsInterfaceWithInternal_jsiiProxy // extends jsii-calc.ImplementsInterfaceWithInternal +type jsiiProxy_ImplementsInterfaceWithInternalSubclass struct { + jsiiProxy_ImplementsInterfaceWithInternal // extends jsii-calc.ImplementsInterfaceWithInternal } func NewImplementsInterfaceWithInternalSubclass() ImplementsInterfaceWithInternalSubclass { _init_.Initialize() - i := implementsInterfaceWithInternalSubclass_jsiiProxy{} + j := jsiiProxy_ImplementsInterfaceWithInternalSubclass{} _jsii_.Create( "jsii-calc.ImplementsInterfaceWithInternalSubclass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } type ImplementsPrivateInterface interface { @@ -7559,14 +7559,14 @@ type ImplementsPrivateInterface interface { } // The jsii proxy struct for ImplementsPrivateInterface -type implementsPrivateInterface_jsiiProxy struct { +type jsiiProxy_ImplementsPrivateInterface struct { _ byte // padding } -func (i *implementsPrivateInterface_jsiiProxy) Private() string { +func (j *jsiiProxy_ImplementsPrivateInterface) Private() string { var returns string _jsii_.Get( - i, + j, "private", &returns, ) @@ -7577,22 +7577,22 @@ func (i *implementsPrivateInterface_jsiiProxy) Private() string { func NewImplementsPrivateInterface() ImplementsPrivateInterface { _init_.Initialize() - i := implementsPrivateInterface_jsiiProxy{} + j := jsiiProxy_ImplementsPrivateInterface{} _jsii_.Create( "jsii-calc.ImplementsPrivateInterface", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } -func (i *implementsPrivateInterface_jsiiProxy) SetPrivate(val string) { +func (j *jsiiProxy_ImplementsPrivateInterface) SetPrivate(val string) { _jsii_.Set( - i, + j, "private", val, ) @@ -7626,28 +7626,28 @@ type InbetweenClass interface { } // The jsii proxy struct for InbetweenClass -type inbetweenClass_jsiiProxy struct { - publicClass_jsiiProxy // extends jsii-calc.PublicClass - iPublicInterface2_jsiiProxy // implements jsii-calc.IPublicInterface2 +type jsiiProxy_InbetweenClass struct { + jsiiProxy_PublicClass // extends jsii-calc.PublicClass + jsiiProxy_IPublicInterface2 // implements jsii-calc.IPublicInterface2 } func NewInbetweenClass() InbetweenClass { _init_.Initialize() - i := inbetweenClass_jsiiProxy{} + j := jsiiProxy_InbetweenClass{} _jsii_.Create( "jsii-calc.InbetweenClass", nil /* no parameters */, []_jsii_.FQN{"jsii-calc.IPublicInterface2"}, nil, // no overrides - &i, + &j, ) - return &i + return &j } -func (i *inbetweenClass_jsiiProxy) Ciao() string { +func (i *jsiiProxy_InbetweenClass) Ciao() string { var returns string _jsii_.Invoke( @@ -7667,7 +7667,7 @@ type InterfaceCollections interface { } // The jsii proxy struct for InterfaceCollections -type interfaceCollections_jsiiProxy struct { +type jsiiProxy_InterfaceCollections struct { _ byte // padding } @@ -7736,7 +7736,7 @@ type InterfacesMaker interface { } // The jsii proxy struct for InterfacesMaker -type interfacesMaker_jsiiProxy struct { +type jsiiProxy_InterfacesMaker struct { _ byte // padding } @@ -7764,27 +7764,27 @@ type Isomorphism interface { } // The jsii proxy struct for Isomorphism -type isomorphism_jsiiProxy struct { +type jsiiProxy_Isomorphism struct { _ byte // padding } func NewIsomorphism() Isomorphism { _init_.Initialize() - i := isomorphism_jsiiProxy{} + j := jsiiProxy_Isomorphism{} _jsii_.Create( "jsii-calc.Isomorphism", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } -func (i *isomorphism_jsiiProxy) Myself() Isomorphism { +func (i *jsiiProxy_Isomorphism) Myself() Isomorphism { var returns Isomorphism _jsii_.Invoke( @@ -7804,7 +7804,7 @@ type Issue2638 interface { } // The jsii proxy struct for Issue2638 -type issue2638_jsiiProxy struct { +type jsiiProxy_Issue2638 struct { _ byte // padding } @@ -7814,41 +7814,41 @@ type issue2638_jsiiProxy struct { func NewIssue2638() Issue2638 { _init_.Initialize() - i := issue2638_jsiiProxy{} + j := jsiiProxy_Issue2638{} _jsii_.Create( "jsii-calc.Issue2638", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } type Issue2638B interface { } // The jsii proxy struct for Issue2638B -type issue2638B_jsiiProxy struct { +type jsiiProxy_Issue2638B struct { _ byte // padding } func NewIssue2638B() Issue2638B { _init_.Initialize() - i := issue2638B_jsiiProxy{} + j := jsiiProxy_Issue2638B{} _jsii_.Create( "jsii-calc.Issue2638B", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } type Jsii417Derived interface { @@ -7859,11 +7859,11 @@ type Jsii417Derived interface { } // The jsii proxy struct for Jsii417Derived -type jsii417Derived_jsiiProxy struct { - jsii417PublicBaseOfBase_jsiiProxy // extends jsii-calc.JSII417PublicBaseOfBase +type jsiiProxy_Jsii417Derived struct { + jsiiProxy_Jsii417PublicBaseOfBase // extends jsii-calc.JSII417PublicBaseOfBase } -func (j *jsii417Derived_jsiiProxy) Property() string { +func (j *jsiiProxy_Jsii417Derived) Property() string { var returns string _jsii_.Get( j, @@ -7877,7 +7877,7 @@ func (j *jsii417Derived_jsiiProxy) Property() string { func NewJsii417Derived(property string) Jsii417Derived { _init_.Initialize() - j := jsii417Derived_jsiiProxy{} + j := jsiiProxy_Jsii417Derived{} _jsii_.Create( "jsii-calc.JSII417Derived", @@ -7890,7 +7890,7 @@ func NewJsii417Derived(property string) Jsii417Derived { return &j } -func (j *jsii417Derived_jsiiProxy) Bar() { +func (j *jsiiProxy_Jsii417Derived) Bar() { _jsii_.InvokeVoid( j, "bar", @@ -7898,7 +7898,7 @@ func (j *jsii417Derived_jsiiProxy) Bar() { ) } -func (j *jsii417Derived_jsiiProxy) Baz() { +func (j *jsiiProxy_Jsii417Derived) Baz() { _jsii_.InvokeVoid( j, "baz", @@ -7912,11 +7912,11 @@ type Jsii417PublicBaseOfBase interface { } // The jsii proxy struct for Jsii417PublicBaseOfBase -type jsii417PublicBaseOfBase_jsiiProxy struct { +type jsiiProxy_Jsii417PublicBaseOfBase struct { _ byte // padding } -func (j *jsii417PublicBaseOfBase_jsiiProxy) HasRoot() bool { +func (j *jsiiProxy_Jsii417PublicBaseOfBase) HasRoot() bool { var returns bool _jsii_.Get( j, @@ -7930,7 +7930,7 @@ func (j *jsii417PublicBaseOfBase_jsiiProxy) HasRoot() bool { func NewJsii417PublicBaseOfBase() Jsii417PublicBaseOfBase { _init_.Initialize() - j := jsii417PublicBaseOfBase_jsiiProxy{} + j := jsiiProxy_Jsii417PublicBaseOfBase{} _jsii_.Create( "jsii-calc.JSII417PublicBaseOfBase", @@ -7958,7 +7958,7 @@ func Jsii417PublicBaseOfBase_MakeInstance() Jsii417PublicBaseOfBase { return returns } -func (j *jsii417PublicBaseOfBase_jsiiProxy) Foo() { +func (j *jsiiProxy_Jsii417PublicBaseOfBase) Foo() { _jsii_.InvokeVoid( j, "foo", @@ -7972,14 +7972,14 @@ type JsObjectLiteralForInterface interface { } // The jsii proxy struct for JsObjectLiteralForInterface -type jsObjectLiteralForInterface_jsiiProxy struct { +type jsiiProxy_JsObjectLiteralForInterface struct { _ byte // padding } func NewJsObjectLiteralForInterface() JsObjectLiteralForInterface { _init_.Initialize() - j := jsObjectLiteralForInterface_jsiiProxy{} + j := jsiiProxy_JsObjectLiteralForInterface{} _jsii_.Create( "jsii-calc.JSObjectLiteralForInterface", @@ -7992,7 +7992,7 @@ func NewJsObjectLiteralForInterface() JsObjectLiteralForInterface { return &j } -func (j *jsObjectLiteralForInterface_jsiiProxy) GiveMeFriendly() scopejsiicalclib.IFriendly { +func (j *jsiiProxy_JsObjectLiteralForInterface) GiveMeFriendly() scopejsiicalclib.IFriendly { var returns scopejsiicalclib.IFriendly _jsii_.Invoke( @@ -8005,7 +8005,7 @@ func (j *jsObjectLiteralForInterface_jsiiProxy) GiveMeFriendly() scopejsiicalcli return returns } -func (j *jsObjectLiteralForInterface_jsiiProxy) GiveMeFriendlyGenerator() IFriendlyRandomGenerator { +func (j *jsiiProxy_JsObjectLiteralForInterface) GiveMeFriendlyGenerator() IFriendlyRandomGenerator { var returns IFriendlyRandomGenerator _jsii_.Invoke( @@ -8023,14 +8023,14 @@ type JsObjectLiteralToNative interface { } // The jsii proxy struct for JsObjectLiteralToNative -type jsObjectLiteralToNative_jsiiProxy struct { +type jsiiProxy_JsObjectLiteralToNative struct { _ byte // padding } func NewJsObjectLiteralToNative() JsObjectLiteralToNative { _init_.Initialize() - j := jsObjectLiteralToNative_jsiiProxy{} + j := jsiiProxy_JsObjectLiteralToNative{} _jsii_.Create( "jsii-calc.JSObjectLiteralToNative", @@ -8043,7 +8043,7 @@ func NewJsObjectLiteralToNative() JsObjectLiteralToNative { return &j } -func (j *jsObjectLiteralToNative_jsiiProxy) ReturnLiteral() JsObjectLiteralToNativeClass { +func (j *jsiiProxy_JsObjectLiteralToNative) ReturnLiteral() JsObjectLiteralToNativeClass { var returns JsObjectLiteralToNativeClass _jsii_.Invoke( @@ -8064,11 +8064,11 @@ type JsObjectLiteralToNativeClass interface { } // The jsii proxy struct for JsObjectLiteralToNativeClass -type jsObjectLiteralToNativeClass_jsiiProxy struct { +type jsiiProxy_JsObjectLiteralToNativeClass struct { _ byte // padding } -func (j *jsObjectLiteralToNativeClass_jsiiProxy) PropA() string { +func (j *jsiiProxy_JsObjectLiteralToNativeClass) PropA() string { var returns string _jsii_.Get( j, @@ -8078,7 +8078,7 @@ func (j *jsObjectLiteralToNativeClass_jsiiProxy) PropA() string { return returns } -func (j *jsObjectLiteralToNativeClass_jsiiProxy) PropB() float64 { +func (j *jsiiProxy_JsObjectLiteralToNativeClass) PropB() float64 { var returns float64 _jsii_.Get( j, @@ -8092,7 +8092,7 @@ func (j *jsObjectLiteralToNativeClass_jsiiProxy) PropB() float64 { func NewJsObjectLiteralToNativeClass() JsObjectLiteralToNativeClass { _init_.Initialize() - j := jsObjectLiteralToNativeClass_jsiiProxy{} + j := jsiiProxy_JsObjectLiteralToNativeClass{} _jsii_.Create( "jsii-calc.JSObjectLiteralToNativeClass", @@ -8105,7 +8105,7 @@ func NewJsObjectLiteralToNativeClass() JsObjectLiteralToNativeClass { return &j } -func (j *jsObjectLiteralToNativeClass_jsiiProxy) SetPropA(val string) { +func (j *jsiiProxy_JsObjectLiteralToNativeClass) SetPropA(val string) { _jsii_.Set( j, "propA", @@ -8113,7 +8113,7 @@ func (j *jsObjectLiteralToNativeClass_jsiiProxy) SetPropA(val string) { ) } -func (j *jsObjectLiteralToNativeClass_jsiiProxy) SetPropB(val float64) { +func (j *jsiiProxy_JsObjectLiteralToNativeClass) SetPropB(val float64) { _jsii_.Set( j, "propB", @@ -8179,11 +8179,11 @@ type JavaReservedWords interface { } // The jsii proxy struct for JavaReservedWords -type javaReservedWords_jsiiProxy struct { +type jsiiProxy_JavaReservedWords struct { _ byte // padding } -func (j *javaReservedWords_jsiiProxy) While() string { +func (j *jsiiProxy_JavaReservedWords) While() string { var returns string _jsii_.Get( j, @@ -8197,7 +8197,7 @@ func (j *javaReservedWords_jsiiProxy) While() string { func NewJavaReservedWords() JavaReservedWords { _init_.Initialize() - j := javaReservedWords_jsiiProxy{} + j := jsiiProxy_JavaReservedWords{} _jsii_.Create( "jsii-calc.JavaReservedWords", @@ -8210,7 +8210,7 @@ func NewJavaReservedWords() JavaReservedWords { return &j } -func (j *javaReservedWords_jsiiProxy) SetWhile(val string) { +func (j *jsiiProxy_JavaReservedWords) SetWhile(val string) { _jsii_.Set( j, "while", @@ -8218,7 +8218,7 @@ func (j *javaReservedWords_jsiiProxy) SetWhile(val string) { ) } -func (j *javaReservedWords_jsiiProxy) Abstract() { +func (j *jsiiProxy_JavaReservedWords) Abstract() { _jsii_.InvokeVoid( j, "abstract", @@ -8226,7 +8226,7 @@ func (j *javaReservedWords_jsiiProxy) Abstract() { ) } -func (j *javaReservedWords_jsiiProxy) Assert() { +func (j *jsiiProxy_JavaReservedWords) Assert() { _jsii_.InvokeVoid( j, "assert", @@ -8234,7 +8234,7 @@ func (j *javaReservedWords_jsiiProxy) Assert() { ) } -func (j *javaReservedWords_jsiiProxy) Boolean() { +func (j *jsiiProxy_JavaReservedWords) Boolean() { _jsii_.InvokeVoid( j, "boolean", @@ -8242,7 +8242,7 @@ func (j *javaReservedWords_jsiiProxy) Boolean() { ) } -func (j *javaReservedWords_jsiiProxy) Break() { +func (j *jsiiProxy_JavaReservedWords) Break() { _jsii_.InvokeVoid( j, "break", @@ -8250,7 +8250,7 @@ func (j *javaReservedWords_jsiiProxy) Break() { ) } -func (j *javaReservedWords_jsiiProxy) Byte() { +func (j *jsiiProxy_JavaReservedWords) Byte() { _jsii_.InvokeVoid( j, "byte", @@ -8258,7 +8258,7 @@ func (j *javaReservedWords_jsiiProxy) Byte() { ) } -func (j *javaReservedWords_jsiiProxy) Case() { +func (j *jsiiProxy_JavaReservedWords) Case() { _jsii_.InvokeVoid( j, "case", @@ -8266,7 +8266,7 @@ func (j *javaReservedWords_jsiiProxy) Case() { ) } -func (j *javaReservedWords_jsiiProxy) Catch() { +func (j *jsiiProxy_JavaReservedWords) Catch() { _jsii_.InvokeVoid( j, "catch", @@ -8274,7 +8274,7 @@ func (j *javaReservedWords_jsiiProxy) Catch() { ) } -func (j *javaReservedWords_jsiiProxy) Char() { +func (j *jsiiProxy_JavaReservedWords) Char() { _jsii_.InvokeVoid( j, "char", @@ -8282,7 +8282,7 @@ func (j *javaReservedWords_jsiiProxy) Char() { ) } -func (j *javaReservedWords_jsiiProxy) Class() { +func (j *jsiiProxy_JavaReservedWords) Class() { _jsii_.InvokeVoid( j, "class", @@ -8290,7 +8290,7 @@ func (j *javaReservedWords_jsiiProxy) Class() { ) } -func (j *javaReservedWords_jsiiProxy) Const() { +func (j *jsiiProxy_JavaReservedWords) Const() { _jsii_.InvokeVoid( j, "const", @@ -8298,7 +8298,7 @@ func (j *javaReservedWords_jsiiProxy) Const() { ) } -func (j *javaReservedWords_jsiiProxy) Continue() { +func (j *jsiiProxy_JavaReservedWords) Continue() { _jsii_.InvokeVoid( j, "continue", @@ -8306,7 +8306,7 @@ func (j *javaReservedWords_jsiiProxy) Continue() { ) } -func (j *javaReservedWords_jsiiProxy) Default() { +func (j *jsiiProxy_JavaReservedWords) Default() { _jsii_.InvokeVoid( j, "default", @@ -8314,7 +8314,7 @@ func (j *javaReservedWords_jsiiProxy) Default() { ) } -func (j *javaReservedWords_jsiiProxy) Do() { +func (j *jsiiProxy_JavaReservedWords) Do() { _jsii_.InvokeVoid( j, "do", @@ -8322,7 +8322,7 @@ func (j *javaReservedWords_jsiiProxy) Do() { ) } -func (j *javaReservedWords_jsiiProxy) Double() { +func (j *jsiiProxy_JavaReservedWords) Double() { _jsii_.InvokeVoid( j, "double", @@ -8330,7 +8330,7 @@ func (j *javaReservedWords_jsiiProxy) Double() { ) } -func (j *javaReservedWords_jsiiProxy) Else() { +func (j *jsiiProxy_JavaReservedWords) Else() { _jsii_.InvokeVoid( j, "else", @@ -8338,7 +8338,7 @@ func (j *javaReservedWords_jsiiProxy) Else() { ) } -func (j *javaReservedWords_jsiiProxy) Enum() { +func (j *jsiiProxy_JavaReservedWords) Enum() { _jsii_.InvokeVoid( j, "enum", @@ -8346,7 +8346,7 @@ func (j *javaReservedWords_jsiiProxy) Enum() { ) } -func (j *javaReservedWords_jsiiProxy) Extends() { +func (j *jsiiProxy_JavaReservedWords) Extends() { _jsii_.InvokeVoid( j, "extends", @@ -8354,7 +8354,7 @@ func (j *javaReservedWords_jsiiProxy) Extends() { ) } -func (j *javaReservedWords_jsiiProxy) False() { +func (j *jsiiProxy_JavaReservedWords) False() { _jsii_.InvokeVoid( j, "false", @@ -8362,7 +8362,7 @@ func (j *javaReservedWords_jsiiProxy) False() { ) } -func (j *javaReservedWords_jsiiProxy) Final() { +func (j *jsiiProxy_JavaReservedWords) Final() { _jsii_.InvokeVoid( j, "final", @@ -8370,7 +8370,7 @@ func (j *javaReservedWords_jsiiProxy) Final() { ) } -func (j *javaReservedWords_jsiiProxy) Finally() { +func (j *jsiiProxy_JavaReservedWords) Finally() { _jsii_.InvokeVoid( j, "finally", @@ -8378,7 +8378,7 @@ func (j *javaReservedWords_jsiiProxy) Finally() { ) } -func (j *javaReservedWords_jsiiProxy) Float() { +func (j *jsiiProxy_JavaReservedWords) Float() { _jsii_.InvokeVoid( j, "float", @@ -8386,7 +8386,7 @@ func (j *javaReservedWords_jsiiProxy) Float() { ) } -func (j *javaReservedWords_jsiiProxy) For() { +func (j *jsiiProxy_JavaReservedWords) For() { _jsii_.InvokeVoid( j, "for", @@ -8394,7 +8394,7 @@ func (j *javaReservedWords_jsiiProxy) For() { ) } -func (j *javaReservedWords_jsiiProxy) Goto() { +func (j *jsiiProxy_JavaReservedWords) Goto() { _jsii_.InvokeVoid( j, "goto", @@ -8402,7 +8402,7 @@ func (j *javaReservedWords_jsiiProxy) Goto() { ) } -func (j *javaReservedWords_jsiiProxy) If() { +func (j *jsiiProxy_JavaReservedWords) If() { _jsii_.InvokeVoid( j, "if", @@ -8410,7 +8410,7 @@ func (j *javaReservedWords_jsiiProxy) If() { ) } -func (j *javaReservedWords_jsiiProxy) Implements() { +func (j *jsiiProxy_JavaReservedWords) Implements() { _jsii_.InvokeVoid( j, "implements", @@ -8418,7 +8418,7 @@ func (j *javaReservedWords_jsiiProxy) Implements() { ) } -func (j *javaReservedWords_jsiiProxy) Import() { +func (j *jsiiProxy_JavaReservedWords) Import() { _jsii_.InvokeVoid( j, "import", @@ -8426,7 +8426,7 @@ func (j *javaReservedWords_jsiiProxy) Import() { ) } -func (j *javaReservedWords_jsiiProxy) Instanceof() { +func (j *jsiiProxy_JavaReservedWords) Instanceof() { _jsii_.InvokeVoid( j, "instanceof", @@ -8434,7 +8434,7 @@ func (j *javaReservedWords_jsiiProxy) Instanceof() { ) } -func (j *javaReservedWords_jsiiProxy) Int() { +func (j *jsiiProxy_JavaReservedWords) Int() { _jsii_.InvokeVoid( j, "int", @@ -8442,7 +8442,7 @@ func (j *javaReservedWords_jsiiProxy) Int() { ) } -func (j *javaReservedWords_jsiiProxy) Interface() { +func (j *jsiiProxy_JavaReservedWords) Interface() { _jsii_.InvokeVoid( j, "interface", @@ -8450,7 +8450,7 @@ func (j *javaReservedWords_jsiiProxy) Interface() { ) } -func (j *javaReservedWords_jsiiProxy) Long() { +func (j *jsiiProxy_JavaReservedWords) Long() { _jsii_.InvokeVoid( j, "long", @@ -8458,7 +8458,7 @@ func (j *javaReservedWords_jsiiProxy) Long() { ) } -func (j *javaReservedWords_jsiiProxy) Native() { +func (j *jsiiProxy_JavaReservedWords) Native() { _jsii_.InvokeVoid( j, "native", @@ -8466,7 +8466,7 @@ func (j *javaReservedWords_jsiiProxy) Native() { ) } -func (j *javaReservedWords_jsiiProxy) New() { +func (j *jsiiProxy_JavaReservedWords) New() { _jsii_.InvokeVoid( j, "new", @@ -8474,7 +8474,7 @@ func (j *javaReservedWords_jsiiProxy) New() { ) } -func (j *javaReservedWords_jsiiProxy) Null() { +func (j *jsiiProxy_JavaReservedWords) Null() { _jsii_.InvokeVoid( j, "null", @@ -8482,7 +8482,7 @@ func (j *javaReservedWords_jsiiProxy) Null() { ) } -func (j *javaReservedWords_jsiiProxy) Package() { +func (j *jsiiProxy_JavaReservedWords) Package() { _jsii_.InvokeVoid( j, "package", @@ -8490,7 +8490,7 @@ func (j *javaReservedWords_jsiiProxy) Package() { ) } -func (j *javaReservedWords_jsiiProxy) Private() { +func (j *jsiiProxy_JavaReservedWords) Private() { _jsii_.InvokeVoid( j, "private", @@ -8498,7 +8498,7 @@ func (j *javaReservedWords_jsiiProxy) Private() { ) } -func (j *javaReservedWords_jsiiProxy) Protected() { +func (j *jsiiProxy_JavaReservedWords) Protected() { _jsii_.InvokeVoid( j, "protected", @@ -8506,7 +8506,7 @@ func (j *javaReservedWords_jsiiProxy) Protected() { ) } -func (j *javaReservedWords_jsiiProxy) Public() { +func (j *jsiiProxy_JavaReservedWords) Public() { _jsii_.InvokeVoid( j, "public", @@ -8514,7 +8514,7 @@ func (j *javaReservedWords_jsiiProxy) Public() { ) } -func (j *javaReservedWords_jsiiProxy) Return() { +func (j *jsiiProxy_JavaReservedWords) Return() { _jsii_.InvokeVoid( j, "return", @@ -8522,7 +8522,7 @@ func (j *javaReservedWords_jsiiProxy) Return() { ) } -func (j *javaReservedWords_jsiiProxy) Short() { +func (j *jsiiProxy_JavaReservedWords) Short() { _jsii_.InvokeVoid( j, "short", @@ -8530,7 +8530,7 @@ func (j *javaReservedWords_jsiiProxy) Short() { ) } -func (j *javaReservedWords_jsiiProxy) Static() { +func (j *jsiiProxy_JavaReservedWords) Static() { _jsii_.InvokeVoid( j, "static", @@ -8538,7 +8538,7 @@ func (j *javaReservedWords_jsiiProxy) Static() { ) } -func (j *javaReservedWords_jsiiProxy) Strictfp() { +func (j *jsiiProxy_JavaReservedWords) Strictfp() { _jsii_.InvokeVoid( j, "strictfp", @@ -8546,7 +8546,7 @@ func (j *javaReservedWords_jsiiProxy) Strictfp() { ) } -func (j *javaReservedWords_jsiiProxy) Super() { +func (j *jsiiProxy_JavaReservedWords) Super() { _jsii_.InvokeVoid( j, "super", @@ -8554,7 +8554,7 @@ func (j *javaReservedWords_jsiiProxy) Super() { ) } -func (j *javaReservedWords_jsiiProxy) Switch() { +func (j *jsiiProxy_JavaReservedWords) Switch() { _jsii_.InvokeVoid( j, "switch", @@ -8562,7 +8562,7 @@ func (j *javaReservedWords_jsiiProxy) Switch() { ) } -func (j *javaReservedWords_jsiiProxy) Synchronized() { +func (j *jsiiProxy_JavaReservedWords) Synchronized() { _jsii_.InvokeVoid( j, "synchronized", @@ -8570,7 +8570,7 @@ func (j *javaReservedWords_jsiiProxy) Synchronized() { ) } -func (j *javaReservedWords_jsiiProxy) This() { +func (j *jsiiProxy_JavaReservedWords) This() { _jsii_.InvokeVoid( j, "this", @@ -8578,7 +8578,7 @@ func (j *javaReservedWords_jsiiProxy) This() { ) } -func (j *javaReservedWords_jsiiProxy) Throw() { +func (j *jsiiProxy_JavaReservedWords) Throw() { _jsii_.InvokeVoid( j, "throw", @@ -8586,7 +8586,7 @@ func (j *javaReservedWords_jsiiProxy) Throw() { ) } -func (j *javaReservedWords_jsiiProxy) Throws() { +func (j *jsiiProxy_JavaReservedWords) Throws() { _jsii_.InvokeVoid( j, "throws", @@ -8594,7 +8594,7 @@ func (j *javaReservedWords_jsiiProxy) Throws() { ) } -func (j *javaReservedWords_jsiiProxy) Transient() { +func (j *jsiiProxy_JavaReservedWords) Transient() { _jsii_.InvokeVoid( j, "transient", @@ -8602,7 +8602,7 @@ func (j *javaReservedWords_jsiiProxy) Transient() { ) } -func (j *javaReservedWords_jsiiProxy) True() { +func (j *jsiiProxy_JavaReservedWords) True() { _jsii_.InvokeVoid( j, "true", @@ -8610,7 +8610,7 @@ func (j *javaReservedWords_jsiiProxy) True() { ) } -func (j *javaReservedWords_jsiiProxy) Try() { +func (j *jsiiProxy_JavaReservedWords) Try() { _jsii_.InvokeVoid( j, "try", @@ -8618,7 +8618,7 @@ func (j *javaReservedWords_jsiiProxy) Try() { ) } -func (j *javaReservedWords_jsiiProxy) Void() { +func (j *jsiiProxy_JavaReservedWords) Void() { _jsii_.InvokeVoid( j, "void", @@ -8626,7 +8626,7 @@ func (j *javaReservedWords_jsiiProxy) Void() { ) } -func (j *javaReservedWords_jsiiProxy) Volatile() { +func (j *jsiiProxy_JavaReservedWords) Volatile() { _jsii_.InvokeVoid( j, "volatile", @@ -8640,15 +8640,15 @@ type Jsii487Derived interface { } // The jsii proxy struct for Jsii487Derived -type jsii487Derived_jsiiProxy struct { - iJsii487External_jsiiProxy // implements jsii-calc.IJsii487External - iJsii487External2_jsiiProxy // implements jsii-calc.IJsii487External2 +type jsiiProxy_Jsii487Derived struct { + jsiiProxy_IJsii487External // implements jsii-calc.IJsii487External + jsiiProxy_IJsii487External2 // implements jsii-calc.IJsii487External2 } func NewJsii487Derived() Jsii487Derived { _init_.Initialize() - j := jsii487Derived_jsiiProxy{} + j := jsiiProxy_Jsii487Derived{} _jsii_.Create( "jsii-calc.Jsii487Derived", @@ -8666,14 +8666,14 @@ type Jsii496Derived interface { } // The jsii proxy struct for Jsii496Derived -type jsii496Derived_jsiiProxy struct { - iJsii496_jsiiProxy // implements jsii-calc.IJsii496 +type jsiiProxy_Jsii496Derived struct { + jsiiProxy_IJsii496 // implements jsii-calc.IJsii496 } func NewJsii496Derived() Jsii496Derived { _init_.Initialize() - j := jsii496Derived_jsiiProxy{} + j := jsiiProxy_Jsii496Derived{} _jsii_.Create( "jsii-calc.Jsii496Derived", @@ -8691,14 +8691,14 @@ type JsiiAgent interface { } // The jsii proxy struct for JsiiAgent -type jsiiAgent_jsiiProxy struct { +type jsiiProxy_JsiiAgent struct { _ byte // padding } func NewJsiiAgent() JsiiAgent { _init_.Initialize() - j := jsiiAgent_jsiiProxy{} + j := jsiiProxy_JsiiAgent{} _jsii_.Create( "jsii-calc.JsiiAgent", @@ -8729,7 +8729,7 @@ type JsonFormatter interface { } // The jsii proxy struct for JsonFormatter -type jsonFormatter_jsiiProxy struct { +type jsiiProxy_JsonFormatter struct { _ byte // padding } @@ -8949,14 +8949,14 @@ type LevelOne interface { } // The jsii proxy struct for LevelOne -type levelOne_jsiiProxy struct { +type jsiiProxy_LevelOne struct { _ byte // padding } -func (l *levelOne_jsiiProxy) Props() LevelOneProps { +func (j *jsiiProxy_LevelOne) Props() LevelOneProps { var returns LevelOneProps _jsii_.Get( - l, + j, "props", &returns, ) @@ -8967,29 +8967,29 @@ func (l *levelOne_jsiiProxy) Props() LevelOneProps { func NewLevelOne(props LevelOneProps) LevelOne { _init_.Initialize() - l := levelOne_jsiiProxy{} + j := jsiiProxy_LevelOne{} _jsii_.Create( "jsii-calc.LevelOne", []interface{}{props}, []_jsii_.FQN{}, nil, // no overrides - &l, + &j, ) - return &l + return &j } -type PropBooleanValue struct { +type LevelOne_PropBooleanValue struct { Value bool \`json:"value"\` } -type PropProperty struct { - Prop PropBooleanValue \`json:"prop"\` +type LevelOne_PropProperty struct { + Prop LevelOne_PropBooleanValue \`json:"prop"\` } type LevelOneProps struct { - Prop PropProperty \`json:"prop"\` + Prop LevelOne_PropProperty \`json:"prop"\` } // jsii#298: show default values in sphinx documentation, and respect newlines. @@ -9038,14 +9038,14 @@ type MethodNamedProperty interface { } // The jsii proxy struct for MethodNamedProperty -type methodNamedProperty_jsiiProxy struct { +type jsiiProxy_MethodNamedProperty struct { _ byte // padding } -func (m *methodNamedProperty_jsiiProxy) Elite() float64 { +func (j *jsiiProxy_MethodNamedProperty) Elite() float64 { var returns float64 _jsii_.Get( - m, + j, "elite", &returns, ) @@ -9056,20 +9056,20 @@ func (m *methodNamedProperty_jsiiProxy) Elite() float64 { func NewMethodNamedProperty() MethodNamedProperty { _init_.Initialize() - m := methodNamedProperty_jsiiProxy{} + j := jsiiProxy_MethodNamedProperty{} _jsii_.Create( "jsii-calc.MethodNamedProperty", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &m, + &j, ) - return &m + return &j } -func (m *methodNamedProperty_jsiiProxy) Property() string { +func (m *jsiiProxy_MethodNamedProperty) Property() string { var returns string _jsii_.Invoke( @@ -9095,36 +9095,36 @@ type Multiply interface { } // The jsii proxy struct for Multiply -type multiply_jsiiProxy struct { - binaryOperation_jsiiProxy // extends jsii-calc.BinaryOperation - iFriendlier_jsiiProxy // implements jsii-calc.IFriendlier - iRandomNumberGenerator_jsiiProxy // implements jsii-calc.IRandomNumberGenerator +type jsiiProxy_Multiply struct { + jsiiProxy_BinaryOperation // extends jsii-calc.BinaryOperation + jsiiProxy_IFriendlier // implements jsii-calc.IFriendlier + jsiiProxy_IRandomNumberGenerator // implements jsii-calc.IRandomNumberGenerator } -func (m *multiply_jsiiProxy) Value() float64 { +func (j *jsiiProxy_Multiply) Value() float64 { var returns float64 _jsii_.Get( - m, + j, "value", &returns, ) return returns } -func (m *multiply_jsiiProxy) Lhs() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Multiply) Lhs() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - m, + j, "lhs", &returns, ) return returns } -func (m *multiply_jsiiProxy) Rhs() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Multiply) Rhs() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - m, + j, "rhs", &returns, ) @@ -9136,21 +9136,21 @@ func (m *multiply_jsiiProxy) Rhs() scopejsiicalclib.NumericValue { func NewMultiply(lhs scopejsiicalclib.NumericValue, rhs scopejsiicalclib.NumericValue) Multiply { _init_.Initialize() - m := multiply_jsiiProxy{} + j := jsiiProxy_Multiply{} _jsii_.Create( "jsii-calc.Multiply", []interface{}{lhs, rhs}, []_jsii_.FQN{"jsii-calc.IFriendlier", "jsii-calc.IRandomNumberGenerator"}, nil, // no overrides - &m, + &j, ) - return &m + return &j } // Say farewell. -func (m *multiply_jsiiProxy) Farewell() string { +func (m *jsiiProxy_Multiply) Farewell() string { var returns string _jsii_.Invoke( @@ -9164,7 +9164,7 @@ func (m *multiply_jsiiProxy) Farewell() string { } // Say goodbye. -func (m *multiply_jsiiProxy) Goodbye() string { +func (m *jsiiProxy_Multiply) Goodbye() string { var returns string _jsii_.Invoke( @@ -9178,7 +9178,7 @@ func (m *multiply_jsiiProxy) Goodbye() string { } // Returns another random number. -func (m *multiply_jsiiProxy) Next() float64 { +func (m *jsiiProxy_Multiply) Next() float64 { var returns float64 _jsii_.Invoke( @@ -9192,7 +9192,7 @@ func (m *multiply_jsiiProxy) Next() float64 { } // (deprecated) String representation of the value. -func (m *multiply_jsiiProxy) ToString() string { +func (m *jsiiProxy_Multiply) ToString() string { var returns string _jsii_.Invoke( @@ -9206,7 +9206,7 @@ func (m *multiply_jsiiProxy) ToString() string { } // (deprecated) Say hello! -func (m *multiply_jsiiProxy) Hello() string { +func (m *jsiiProxy_Multiply) Hello() string { var returns string _jsii_.Invoke( @@ -9220,7 +9220,7 @@ func (m *multiply_jsiiProxy) Hello() string { } // Returns: the name of the class (to verify native type names are created for derived classes). -func (m *multiply_jsiiProxy) TypeName() interface{} { +func (m *jsiiProxy_Multiply) TypeName() interface{} { var returns interface{} _jsii_.Invoke( @@ -9245,25 +9245,25 @@ type Negate interface { } // The jsii proxy struct for Negate -type negate_jsiiProxy struct { - unaryOperation_jsiiProxy // extends jsii-calc.UnaryOperation - iFriendlier_jsiiProxy // implements jsii-calc.IFriendlier +type jsiiProxy_Negate struct { + jsiiProxy_UnaryOperation // extends jsii-calc.UnaryOperation + jsiiProxy_IFriendlier // implements jsii-calc.IFriendlier } -func (n *negate_jsiiProxy) Value() float64 { +func (j *jsiiProxy_Negate) Value() float64 { var returns float64 _jsii_.Get( - n, + j, "value", &returns, ) return returns } -func (n *negate_jsiiProxy) Operand() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Negate) Operand() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - n, + j, "operand", &returns, ) @@ -9274,21 +9274,21 @@ func (n *negate_jsiiProxy) Operand() scopejsiicalclib.NumericValue { func NewNegate(operand scopejsiicalclib.NumericValue) Negate { _init_.Initialize() - n := negate_jsiiProxy{} + j := jsiiProxy_Negate{} _jsii_.Create( "jsii-calc.Negate", []interface{}{operand}, []_jsii_.FQN{"jsii-calc.IFriendlier"}, nil, // no overrides - &n, + &j, ) - return &n + return &j } // Say farewell. -func (n *negate_jsiiProxy) Farewell() string { +func (n *jsiiProxy_Negate) Farewell() string { var returns string _jsii_.Invoke( @@ -9302,7 +9302,7 @@ func (n *negate_jsiiProxy) Farewell() string { } // Say goodbye. -func (n *negate_jsiiProxy) Goodbye() string { +func (n *jsiiProxy_Negate) Goodbye() string { var returns string _jsii_.Invoke( @@ -9316,7 +9316,7 @@ func (n *negate_jsiiProxy) Goodbye() string { } // (deprecated) Say hello! -func (n *negate_jsiiProxy) Hello() string { +func (n *jsiiProxy_Negate) Hello() string { var returns string _jsii_.Invoke( @@ -9330,7 +9330,7 @@ func (n *negate_jsiiProxy) Hello() string { } // (deprecated) String representation of the value. -func (n *negate_jsiiProxy) ToString() string { +func (n *jsiiProxy_Negate) ToString() string { var returns string _jsii_.Invoke( @@ -9344,7 +9344,7 @@ func (n *negate_jsiiProxy) ToString() string { } // Returns: the name of the class (to verify native type names are created for derived classes). -func (n *negate_jsiiProxy) TypeName() interface{} { +func (n *jsiiProxy_Negate) TypeName() interface{} { var returns interface{} _jsii_.Invoke( @@ -9361,14 +9361,14 @@ type NestedClassInstance interface { } // The jsii proxy struct for NestedClassInstance -type nestedClassInstance_jsiiProxy struct { +type jsiiProxy_NestedClassInstance struct { _ byte // padding } -func NestedClassInstance_MakeInstance() submodule.NestedClass { +func NestedClassInstance_MakeInstance() submodule.NestingClass_NestedClass { _init_.Initialize() - var returns submodule.NestedClass + var returns submodule.NestingClass_NestedClass _jsii_.StaticInvoke( "jsii-calc.NestedClassInstance", @@ -9394,14 +9394,14 @@ type NodeStandardLibrary interface { } // The jsii proxy struct for NodeStandardLibrary -type nodeStandardLibrary_jsiiProxy struct { +type jsiiProxy_NodeStandardLibrary struct { _ byte // padding } -func (n *nodeStandardLibrary_jsiiProxy) OsPlatform() string { +func (j *jsiiProxy_NodeStandardLibrary) OsPlatform() string { var returns string _jsii_.Get( - n, + j, "osPlatform", &returns, ) @@ -9412,23 +9412,23 @@ func (n *nodeStandardLibrary_jsiiProxy) OsPlatform() string { func NewNodeStandardLibrary() NodeStandardLibrary { _init_.Initialize() - n := nodeStandardLibrary_jsiiProxy{} + j := jsiiProxy_NodeStandardLibrary{} _jsii_.Create( "jsii-calc.NodeStandardLibrary", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &n, + &j, ) - return &n + return &j } // Uses node.js "crypto" module to calculate sha256 of a string. // // Returns: "6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50" -func (n *nodeStandardLibrary_jsiiProxy) CryptoSha256() string { +func (n *jsiiProxy_NodeStandardLibrary) CryptoSha256() string { var returns string _jsii_.Invoke( @@ -9444,7 +9444,7 @@ func (n *nodeStandardLibrary_jsiiProxy) CryptoSha256() string { // Reads a local resource file (resource.txt) asynchronously. // // Returns: "Hello, resource!" -func (n *nodeStandardLibrary_jsiiProxy) FsReadFile() string { +func (n *jsiiProxy_NodeStandardLibrary) FsReadFile() string { var returns string _jsii_.Invoke( @@ -9460,7 +9460,7 @@ func (n *nodeStandardLibrary_jsiiProxy) FsReadFile() string { // Sync version of fsReadFile. // // Returns: "Hello, resource! SYNC!" -func (n *nodeStandardLibrary_jsiiProxy) FsReadFileSync() string { +func (n *jsiiProxy_NodeStandardLibrary) FsReadFileSync() string { var returns string _jsii_.Invoke( @@ -9483,14 +9483,14 @@ type NullShouldBeTreatedAsUndefined interface { } // The jsii proxy struct for NullShouldBeTreatedAsUndefined -type nullShouldBeTreatedAsUndefined_jsiiProxy struct { +type jsiiProxy_NullShouldBeTreatedAsUndefined struct { _ byte // padding } -func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) ChangeMeToUndefined() string { +func (j *jsiiProxy_NullShouldBeTreatedAsUndefined) ChangeMeToUndefined() string { var returns string _jsii_.Get( - n, + j, "changeMeToUndefined", &returns, ) @@ -9501,28 +9501,28 @@ func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) ChangeMeToUndefined() string func NewNullShouldBeTreatedAsUndefined(_param1 string, optional interface{}) NullShouldBeTreatedAsUndefined { _init_.Initialize() - n := nullShouldBeTreatedAsUndefined_jsiiProxy{} + j := jsiiProxy_NullShouldBeTreatedAsUndefined{} _jsii_.Create( "jsii-calc.NullShouldBeTreatedAsUndefined", []interface{}{_param1, optional}, []_jsii_.FQN{}, nil, // no overrides - &n, + &j, ) - return &n + return &j } -func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) SetChangeMeToUndefined(val string) { +func (j *jsiiProxy_NullShouldBeTreatedAsUndefined) SetChangeMeToUndefined(val string) { _jsii_.Set( - n, + j, "changeMeToUndefined", val, ) } -func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) GiveMeUndefined(value interface{}) { +func (n *jsiiProxy_NullShouldBeTreatedAsUndefined) GiveMeUndefined(value interface{}) { _jsii_.InvokeVoid( n, "giveMeUndefined", @@ -9530,7 +9530,7 @@ func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) GiveMeUndefined(value interfa ) } -func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) GiveMeUndefinedInsideAnObject(input NullShouldBeTreatedAsUndefinedData) { +func (n *jsiiProxy_NullShouldBeTreatedAsUndefined) GiveMeUndefinedInsideAnObject(input NullShouldBeTreatedAsUndefinedData) { _jsii_.InvokeVoid( n, "giveMeUndefinedInsideAnObject", @@ -9538,7 +9538,7 @@ func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) GiveMeUndefinedInsideAnObject ) } -func (n *nullShouldBeTreatedAsUndefined_jsiiProxy) VerifyPropertyIsUndefined() { +func (n *jsiiProxy_NullShouldBeTreatedAsUndefined) VerifyPropertyIsUndefined() { _jsii_.InvokeVoid( n, "verifyPropertyIsUndefined", @@ -9560,14 +9560,14 @@ type NumberGenerator interface { } // The jsii proxy struct for NumberGenerator -type numberGenerator_jsiiProxy struct { +type jsiiProxy_NumberGenerator struct { _ byte // padding } -func (n *numberGenerator_jsiiProxy) Generator() IRandomNumberGenerator { +func (j *jsiiProxy_NumberGenerator) Generator() IRandomNumberGenerator { var returns IRandomNumberGenerator _jsii_.Get( - n, + j, "generator", &returns, ) @@ -9578,28 +9578,28 @@ func (n *numberGenerator_jsiiProxy) Generator() IRandomNumberGenerator { func NewNumberGenerator(generator IRandomNumberGenerator) NumberGenerator { _init_.Initialize() - n := numberGenerator_jsiiProxy{} + j := jsiiProxy_NumberGenerator{} _jsii_.Create( "jsii-calc.NumberGenerator", []interface{}{generator}, []_jsii_.FQN{}, nil, // no overrides - &n, + &j, ) - return &n + return &j } -func (n *numberGenerator_jsiiProxy) SetGenerator(val IRandomNumberGenerator) { +func (j *jsiiProxy_NumberGenerator) SetGenerator(val IRandomNumberGenerator) { _jsii_.Set( - n, + j, "generator", val, ) } -func (n *numberGenerator_jsiiProxy) IsSameGenerator(gen IRandomNumberGenerator) bool { +func (n *jsiiProxy_NumberGenerator) IsSameGenerator(gen IRandomNumberGenerator) bool { var returns bool _jsii_.Invoke( @@ -9612,7 +9612,7 @@ func (n *numberGenerator_jsiiProxy) IsSameGenerator(gen IRandomNumberGenerator) return returns } -func (n *numberGenerator_jsiiProxy) NextTimes100() float64 { +func (n *jsiiProxy_NumberGenerator) NextTimes100() float64 { var returns float64 _jsii_.Invoke( @@ -9632,28 +9632,28 @@ type ObjectRefsInCollections interface { } // The jsii proxy struct for ObjectRefsInCollections -type objectRefsInCollections_jsiiProxy struct { +type jsiiProxy_ObjectRefsInCollections struct { _ byte // padding } func NewObjectRefsInCollections() ObjectRefsInCollections { _init_.Initialize() - o := objectRefsInCollections_jsiiProxy{} + j := jsiiProxy_ObjectRefsInCollections{} _jsii_.Create( "jsii-calc.ObjectRefsInCollections", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } // Returns the sum of all values. -func (o *objectRefsInCollections_jsiiProxy) SumFromArray(values []scopejsiicalclib.NumericValue) float64 { +func (o *jsiiProxy_ObjectRefsInCollections) SumFromArray(values []scopejsiicalclib.NumericValue) float64 { var returns float64 _jsii_.Invoke( @@ -9667,7 +9667,7 @@ func (o *objectRefsInCollections_jsiiProxy) SumFromArray(values []scopejsiicalcl } // Returns the sum of all values in a map. -func (o *objectRefsInCollections_jsiiProxy) SumFromMap(values map[string]scopejsiicalclib.NumericValue) float64 { +func (o *jsiiProxy_ObjectRefsInCollections) SumFromMap(values map[string]scopejsiicalclib.NumericValue) float64 { var returns float64 _jsii_.Invoke( @@ -9684,7 +9684,7 @@ type ObjectWithPropertyProvider interface { } // The jsii proxy struct for ObjectWithPropertyProvider -type objectWithPropertyProvider_jsiiProxy struct { +type jsiiProxy_ObjectWithPropertyProvider struct { _ byte // padding } @@ -9711,7 +9711,7 @@ type Old interface { } // The jsii proxy struct for Old -type old_jsiiProxy struct { +type jsiiProxy_Old struct { _ byte // padding } @@ -9720,23 +9720,23 @@ type old_jsiiProxy struct { func NewOld() Old { _init_.Initialize() - o := old_jsiiProxy{} + j := jsiiProxy_Old{} _jsii_.Create( "jsii-calc.Old", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } // Doo wop that thing. // Deprecated: Use the new class or the old class whatever you want because // whatever you like is always the best -func (o *old_jsiiProxy) DoAThing() { +func (o *jsiiProxy_Old) DoAThing() { _jsii_.InvokeVoid( o, "doAThing", @@ -9750,27 +9750,27 @@ type OptionalArgumentInvoker interface { } // The jsii proxy struct for OptionalArgumentInvoker -type optionalArgumentInvoker_jsiiProxy struct { +type jsiiProxy_OptionalArgumentInvoker struct { _ byte // padding } func NewOptionalArgumentInvoker(delegate IInterfaceWithOptionalMethodArguments) OptionalArgumentInvoker { _init_.Initialize() - o := optionalArgumentInvoker_jsiiProxy{} + j := jsiiProxy_OptionalArgumentInvoker{} _jsii_.Create( "jsii-calc.OptionalArgumentInvoker", []interface{}{delegate}, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } -func (o *optionalArgumentInvoker_jsiiProxy) InvokeWithOptional() { +func (o *jsiiProxy_OptionalArgumentInvoker) InvokeWithOptional() { _jsii_.InvokeVoid( o, "invokeWithOptional", @@ -9778,7 +9778,7 @@ func (o *optionalArgumentInvoker_jsiiProxy) InvokeWithOptional() { ) } -func (o *optionalArgumentInvoker_jsiiProxy) InvokeWithoutOptional() { +func (o *jsiiProxy_OptionalArgumentInvoker) InvokeWithoutOptional() { _jsii_.InvokeVoid( o, "invokeWithoutOptional", @@ -9793,34 +9793,34 @@ type OptionalConstructorArgument interface { } // The jsii proxy struct for OptionalConstructorArgument -type optionalConstructorArgument_jsiiProxy struct { +type jsiiProxy_OptionalConstructorArgument struct { _ byte // padding } -func (o *optionalConstructorArgument_jsiiProxy) Arg1() float64 { +func (j *jsiiProxy_OptionalConstructorArgument) Arg1() float64 { var returns float64 _jsii_.Get( - o, + j, "arg1", &returns, ) return returns } -func (o *optionalConstructorArgument_jsiiProxy) Arg2() string { +func (j *jsiiProxy_OptionalConstructorArgument) Arg2() string { var returns string _jsii_.Get( - o, + j, "arg2", &returns, ) return returns } -func (o *optionalConstructorArgument_jsiiProxy) Arg3() string { +func (j *jsiiProxy_OptionalConstructorArgument) Arg3() string { var returns string _jsii_.Get( - o, + j, "arg3", &returns, ) @@ -9831,17 +9831,17 @@ func (o *optionalConstructorArgument_jsiiProxy) Arg3() string { func NewOptionalConstructorArgument(arg1 float64, arg2 string, arg3 string) OptionalConstructorArgument { _init_.Initialize() - o := optionalConstructorArgument_jsiiProxy{} + j := jsiiProxy_OptionalConstructorArgument{} _jsii_.Create( "jsii-calc.OptionalConstructorArgument", []interface{}{arg1, arg2, arg3}, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } type OptionalStruct struct { @@ -9854,24 +9854,24 @@ type OptionalStructConsumer interface { } // The jsii proxy struct for OptionalStructConsumer -type optionalStructConsumer_jsiiProxy struct { +type jsiiProxy_OptionalStructConsumer struct { _ byte // padding } -func (o *optionalStructConsumer_jsiiProxy) FieldValue() string { +func (j *jsiiProxy_OptionalStructConsumer) FieldValue() string { var returns string _jsii_.Get( - o, + j, "fieldValue", &returns, ) return returns } -func (o *optionalStructConsumer_jsiiProxy) ParameterWasUndefined() bool { +func (j *jsiiProxy_OptionalStructConsumer) ParameterWasUndefined() bool { var returns bool _jsii_.Get( - o, + j, "parameterWasUndefined", &returns, ) @@ -9882,17 +9882,17 @@ func (o *optionalStructConsumer_jsiiProxy) ParameterWasUndefined() bool { func NewOptionalStructConsumer(optionalStruct OptionalStruct) OptionalStructConsumer { _init_.Initialize() - o := optionalStructConsumer_jsiiProxy{} + j := jsiiProxy_OptionalStructConsumer{} _jsii_.Create( "jsii-calc.OptionalStructConsumer", []interface{}{optionalStruct}, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } // See: https://github.com/aws/jsii/issues/903 @@ -9906,24 +9906,24 @@ type OverridableProtectedMember interface { } // The jsii proxy struct for OverridableProtectedMember -type overridableProtectedMember_jsiiProxy struct { +type jsiiProxy_OverridableProtectedMember struct { _ byte // padding } -func (o *overridableProtectedMember_jsiiProxy) OverrideReadOnly() string { +func (j *jsiiProxy_OverridableProtectedMember) OverrideReadOnly() string { var returns string _jsii_.Get( - o, + j, "overrideReadOnly", &returns, ) return returns } -func (o *overridableProtectedMember_jsiiProxy) OverrideReadWrite() string { +func (j *jsiiProxy_OverridableProtectedMember) OverrideReadWrite() string { var returns string _jsii_.Get( - o, + j, "overrideReadWrite", &returns, ) @@ -9934,28 +9934,28 @@ func (o *overridableProtectedMember_jsiiProxy) OverrideReadWrite() string { func NewOverridableProtectedMember() OverridableProtectedMember { _init_.Initialize() - o := overridableProtectedMember_jsiiProxy{} + j := jsiiProxy_OverridableProtectedMember{} _jsii_.Create( "jsii-calc.OverridableProtectedMember", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } -func (o *overridableProtectedMember_jsiiProxy) SetOverrideReadWrite(val string) { +func (j *jsiiProxy_OverridableProtectedMember) SetOverrideReadWrite(val string) { _jsii_.Set( - o, + j, "overrideReadWrite", val, ) } -func (o *overridableProtectedMember_jsiiProxy) OverrideMe() string { +func (o *jsiiProxy_OverridableProtectedMember) OverrideMe() string { var returns string _jsii_.Invoke( @@ -9968,7 +9968,7 @@ func (o *overridableProtectedMember_jsiiProxy) OverrideMe() string { return returns } -func (o *overridableProtectedMember_jsiiProxy) SwitchModes() { +func (o *jsiiProxy_OverridableProtectedMember) SwitchModes() { _jsii_.InvokeVoid( o, "switchModes", @@ -9976,7 +9976,7 @@ func (o *overridableProtectedMember_jsiiProxy) SwitchModes() { ) } -func (o *overridableProtectedMember_jsiiProxy) ValueFromProtected() string { +func (o *jsiiProxy_OverridableProtectedMember) ValueFromProtected() string { var returns string _jsii_.Invoke( @@ -9994,27 +9994,27 @@ type OverrideReturnsObject interface { } // The jsii proxy struct for OverrideReturnsObject -type overrideReturnsObject_jsiiProxy struct { +type jsiiProxy_OverrideReturnsObject struct { _ byte // padding } func NewOverrideReturnsObject() OverrideReturnsObject { _init_.Initialize() - o := overrideReturnsObject_jsiiProxy{} + j := jsiiProxy_OverrideReturnsObject{} _jsii_.Create( "jsii-calc.OverrideReturnsObject", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } -func (o *overrideReturnsObject_jsiiProxy) Test(obj IReturnsNumber) float64 { +func (o *jsiiProxy_OverrideReturnsObject) Test(obj IReturnsNumber) float64 { var returns float64 _jsii_.Invoke( @@ -10037,27 +10037,27 @@ type PartiallyInitializedThisConsumer interface { } // The jsii proxy struct for PartiallyInitializedThisConsumer -type partiallyInitializedThisConsumer_jsiiProxy struct { +type jsiiProxy_PartiallyInitializedThisConsumer struct { _ byte // padding } func NewPartiallyInitializedThisConsumer() PartiallyInitializedThisConsumer { _init_.Initialize() - p := partiallyInitializedThisConsumer_jsiiProxy{} + j := jsiiProxy_PartiallyInitializedThisConsumer{} _jsii_.Create( "jsii-calc.PartiallyInitializedThisConsumer", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } -func (p *partiallyInitializedThisConsumer_jsiiProxy) ConsumePartiallyInitializedThis(obj ConstructorPassesThisOut, dt string, ev AllTypesEnum) string { +func (p *jsiiProxy_PartiallyInitializedThisConsumer) ConsumePartiallyInitializedThis(obj ConstructorPassesThisOut, dt string, ev AllTypesEnum) string { var returns string _jsii_.Invoke( @@ -10075,27 +10075,27 @@ type Polymorphism interface { } // The jsii proxy struct for Polymorphism -type polymorphism_jsiiProxy struct { +type jsiiProxy_Polymorphism struct { _ byte // padding } func NewPolymorphism() Polymorphism { _init_.Initialize() - p := polymorphism_jsiiProxy{} + j := jsiiProxy_Polymorphism{} _jsii_.Create( "jsii-calc.Polymorphism", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } -func (p *polymorphism_jsiiProxy) SayHello(friendly scopejsiicalclib.IFriendly) string { +func (p *jsiiProxy_Polymorphism) SayHello(friendly scopejsiicalclib.IFriendly) string { var returns string _jsii_.Invoke( @@ -10117,34 +10117,34 @@ type Power interface { } // The jsii proxy struct for Power -type power_jsiiProxy struct { +type jsiiProxy_Power struct { composition.CompositeOperation // extends jsii-calc.composition.CompositeOperation } -func (p *power_jsiiProxy) Base() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Power) Base() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - p, + j, "base", &returns, ) return returns } -func (p *power_jsiiProxy) Expression() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Power) Expression() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - p, + j, "expression", &returns, ) return returns } -func (p *power_jsiiProxy) Pow() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Power) Pow() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - p, + j, "pow", &returns, ) @@ -10156,17 +10156,17 @@ func (p *power_jsiiProxy) Pow() scopejsiicalclib.NumericValue { func NewPower(base scopejsiicalclib.NumericValue, pow scopejsiicalclib.NumericValue) Power { _init_.Initialize() - p := power_jsiiProxy{} + j := jsiiProxy_Power{} _jsii_.Create( "jsii-calc.Power", []interface{}{base, pow}, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } // Reproduction for https://github.com/aws/jsii/issues/1113 Where a method or property named "property" would result in impossible to load Python code. @@ -10176,24 +10176,24 @@ type PropertyNamedProperty interface { } // The jsii proxy struct for PropertyNamedProperty -type propertyNamedProperty_jsiiProxy struct { +type jsiiProxy_PropertyNamedProperty struct { _ byte // padding } -func (p *propertyNamedProperty_jsiiProxy) Property() string { +func (j *jsiiProxy_PropertyNamedProperty) Property() string { var returns string _jsii_.Get( - p, + j, "property", &returns, ) return returns } -func (p *propertyNamedProperty_jsiiProxy) YetAnoterOne() bool { +func (j *jsiiProxy_PropertyNamedProperty) YetAnoterOne() bool { var returns bool _jsii_.Get( - p, + j, "yetAnoterOne", &returns, ) @@ -10204,17 +10204,17 @@ func (p *propertyNamedProperty_jsiiProxy) YetAnoterOne() bool { func NewPropertyNamedProperty() PropertyNamedProperty { _init_.Initialize() - p := propertyNamedProperty_jsiiProxy{} + j := jsiiProxy_PropertyNamedProperty{} _jsii_.Create( "jsii-calc.PropertyNamedProperty", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } type PublicClass interface { @@ -10222,27 +10222,27 @@ type PublicClass interface { } // The jsii proxy struct for PublicClass -type publicClass_jsiiProxy struct { +type jsiiProxy_PublicClass struct { _ byte // padding } func NewPublicClass() PublicClass { _init_.Initialize() - p := publicClass_jsiiProxy{} + j := jsiiProxy_PublicClass{} _jsii_.Create( "jsii-calc.PublicClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } -func (p *publicClass_jsiiProxy) Hello() { +func (p *jsiiProxy_PublicClass) Hello() { _jsii_.InvokeVoid( p, "hello", @@ -10286,27 +10286,27 @@ type PythonReservedWords interface { } // The jsii proxy struct for PythonReservedWords -type pythonReservedWords_jsiiProxy struct { +type jsiiProxy_PythonReservedWords struct { _ byte // padding } func NewPythonReservedWords() PythonReservedWords { _init_.Initialize() - p := pythonReservedWords_jsiiProxy{} + j := jsiiProxy_PythonReservedWords{} _jsii_.Create( "jsii-calc.PythonReservedWords", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &p, + &j, ) - return &p + return &j } -func (p *pythonReservedWords_jsiiProxy) And() { +func (p *jsiiProxy_PythonReservedWords) And() { _jsii_.InvokeVoid( p, "and", @@ -10314,7 +10314,7 @@ func (p *pythonReservedWords_jsiiProxy) And() { ) } -func (p *pythonReservedWords_jsiiProxy) As() { +func (p *jsiiProxy_PythonReservedWords) As() { _jsii_.InvokeVoid( p, "as", @@ -10322,7 +10322,7 @@ func (p *pythonReservedWords_jsiiProxy) As() { ) } -func (p *pythonReservedWords_jsiiProxy) Assert() { +func (p *jsiiProxy_PythonReservedWords) Assert() { _jsii_.InvokeVoid( p, "assert", @@ -10330,7 +10330,7 @@ func (p *pythonReservedWords_jsiiProxy) Assert() { ) } -func (p *pythonReservedWords_jsiiProxy) Async() { +func (p *jsiiProxy_PythonReservedWords) Async() { _jsii_.InvokeVoid( p, "async", @@ -10338,7 +10338,7 @@ func (p *pythonReservedWords_jsiiProxy) Async() { ) } -func (p *pythonReservedWords_jsiiProxy) Await() { +func (p *jsiiProxy_PythonReservedWords) Await() { _jsii_.InvokeVoid( p, "await", @@ -10346,7 +10346,7 @@ func (p *pythonReservedWords_jsiiProxy) Await() { ) } -func (p *pythonReservedWords_jsiiProxy) Break() { +func (p *jsiiProxy_PythonReservedWords) Break() { _jsii_.InvokeVoid( p, "break", @@ -10354,7 +10354,7 @@ func (p *pythonReservedWords_jsiiProxy) Break() { ) } -func (p *pythonReservedWords_jsiiProxy) Class() { +func (p *jsiiProxy_PythonReservedWords) Class() { _jsii_.InvokeVoid( p, "class", @@ -10362,7 +10362,7 @@ func (p *pythonReservedWords_jsiiProxy) Class() { ) } -func (p *pythonReservedWords_jsiiProxy) Continue() { +func (p *jsiiProxy_PythonReservedWords) Continue() { _jsii_.InvokeVoid( p, "continue", @@ -10370,7 +10370,7 @@ func (p *pythonReservedWords_jsiiProxy) Continue() { ) } -func (p *pythonReservedWords_jsiiProxy) Def() { +func (p *jsiiProxy_PythonReservedWords) Def() { _jsii_.InvokeVoid( p, "def", @@ -10378,7 +10378,7 @@ func (p *pythonReservedWords_jsiiProxy) Def() { ) } -func (p *pythonReservedWords_jsiiProxy) Del() { +func (p *jsiiProxy_PythonReservedWords) Del() { _jsii_.InvokeVoid( p, "del", @@ -10386,7 +10386,7 @@ func (p *pythonReservedWords_jsiiProxy) Del() { ) } -func (p *pythonReservedWords_jsiiProxy) Elif() { +func (p *jsiiProxy_PythonReservedWords) Elif() { _jsii_.InvokeVoid( p, "elif", @@ -10394,7 +10394,7 @@ func (p *pythonReservedWords_jsiiProxy) Elif() { ) } -func (p *pythonReservedWords_jsiiProxy) Else() { +func (p *jsiiProxy_PythonReservedWords) Else() { _jsii_.InvokeVoid( p, "else", @@ -10402,7 +10402,7 @@ func (p *pythonReservedWords_jsiiProxy) Else() { ) } -func (p *pythonReservedWords_jsiiProxy) Except() { +func (p *jsiiProxy_PythonReservedWords) Except() { _jsii_.InvokeVoid( p, "except", @@ -10410,7 +10410,7 @@ func (p *pythonReservedWords_jsiiProxy) Except() { ) } -func (p *pythonReservedWords_jsiiProxy) Finally() { +func (p *jsiiProxy_PythonReservedWords) Finally() { _jsii_.InvokeVoid( p, "finally", @@ -10418,7 +10418,7 @@ func (p *pythonReservedWords_jsiiProxy) Finally() { ) } -func (p *pythonReservedWords_jsiiProxy) For() { +func (p *jsiiProxy_PythonReservedWords) For() { _jsii_.InvokeVoid( p, "for", @@ -10426,7 +10426,7 @@ func (p *pythonReservedWords_jsiiProxy) For() { ) } -func (p *pythonReservedWords_jsiiProxy) From() { +func (p *jsiiProxy_PythonReservedWords) From() { _jsii_.InvokeVoid( p, "from", @@ -10434,7 +10434,7 @@ func (p *pythonReservedWords_jsiiProxy) From() { ) } -func (p *pythonReservedWords_jsiiProxy) Global() { +func (p *jsiiProxy_PythonReservedWords) Global() { _jsii_.InvokeVoid( p, "global", @@ -10442,7 +10442,7 @@ func (p *pythonReservedWords_jsiiProxy) Global() { ) } -func (p *pythonReservedWords_jsiiProxy) If() { +func (p *jsiiProxy_PythonReservedWords) If() { _jsii_.InvokeVoid( p, "if", @@ -10450,7 +10450,7 @@ func (p *pythonReservedWords_jsiiProxy) If() { ) } -func (p *pythonReservedWords_jsiiProxy) Import() { +func (p *jsiiProxy_PythonReservedWords) Import() { _jsii_.InvokeVoid( p, "import", @@ -10458,7 +10458,7 @@ func (p *pythonReservedWords_jsiiProxy) Import() { ) } -func (p *pythonReservedWords_jsiiProxy) In() { +func (p *jsiiProxy_PythonReservedWords) In() { _jsii_.InvokeVoid( p, "in", @@ -10466,7 +10466,7 @@ func (p *pythonReservedWords_jsiiProxy) In() { ) } -func (p *pythonReservedWords_jsiiProxy) Is() { +func (p *jsiiProxy_PythonReservedWords) Is() { _jsii_.InvokeVoid( p, "is", @@ -10474,7 +10474,7 @@ func (p *pythonReservedWords_jsiiProxy) Is() { ) } -func (p *pythonReservedWords_jsiiProxy) Lambda() { +func (p *jsiiProxy_PythonReservedWords) Lambda() { _jsii_.InvokeVoid( p, "lambda", @@ -10482,7 +10482,7 @@ func (p *pythonReservedWords_jsiiProxy) Lambda() { ) } -func (p *pythonReservedWords_jsiiProxy) Nonlocal() { +func (p *jsiiProxy_PythonReservedWords) Nonlocal() { _jsii_.InvokeVoid( p, "nonlocal", @@ -10490,7 +10490,7 @@ func (p *pythonReservedWords_jsiiProxy) Nonlocal() { ) } -func (p *pythonReservedWords_jsiiProxy) Not() { +func (p *jsiiProxy_PythonReservedWords) Not() { _jsii_.InvokeVoid( p, "not", @@ -10498,7 +10498,7 @@ func (p *pythonReservedWords_jsiiProxy) Not() { ) } -func (p *pythonReservedWords_jsiiProxy) Or() { +func (p *jsiiProxy_PythonReservedWords) Or() { _jsii_.InvokeVoid( p, "or", @@ -10506,7 +10506,7 @@ func (p *pythonReservedWords_jsiiProxy) Or() { ) } -func (p *pythonReservedWords_jsiiProxy) Pass() { +func (p *jsiiProxy_PythonReservedWords) Pass() { _jsii_.InvokeVoid( p, "pass", @@ -10514,7 +10514,7 @@ func (p *pythonReservedWords_jsiiProxy) Pass() { ) } -func (p *pythonReservedWords_jsiiProxy) Raise() { +func (p *jsiiProxy_PythonReservedWords) Raise() { _jsii_.InvokeVoid( p, "raise", @@ -10522,7 +10522,7 @@ func (p *pythonReservedWords_jsiiProxy) Raise() { ) } -func (p *pythonReservedWords_jsiiProxy) Return() { +func (p *jsiiProxy_PythonReservedWords) Return() { _jsii_.InvokeVoid( p, "return", @@ -10530,7 +10530,7 @@ func (p *pythonReservedWords_jsiiProxy) Return() { ) } -func (p *pythonReservedWords_jsiiProxy) Try() { +func (p *jsiiProxy_PythonReservedWords) Try() { _jsii_.InvokeVoid( p, "try", @@ -10538,7 +10538,7 @@ func (p *pythonReservedWords_jsiiProxy) Try() { ) } -func (p *pythonReservedWords_jsiiProxy) While() { +func (p *jsiiProxy_PythonReservedWords) While() { _jsii_.InvokeVoid( p, "while", @@ -10546,7 +10546,7 @@ func (p *pythonReservedWords_jsiiProxy) While() { ) } -func (p *pythonReservedWords_jsiiProxy) With() { +func (p *jsiiProxy_PythonReservedWords) With() { _jsii_.InvokeVoid( p, "with", @@ -10554,7 +10554,7 @@ func (p *pythonReservedWords_jsiiProxy) With() { ) } -func (p *pythonReservedWords_jsiiProxy) Yield() { +func (p *jsiiProxy_PythonReservedWords) Yield() { _jsii_.InvokeVoid( p, "yield", @@ -10571,14 +10571,14 @@ type ReferenceEnumFromScopedPackage interface { } // The jsii proxy struct for ReferenceEnumFromScopedPackage -type referenceEnumFromScopedPackage_jsiiProxy struct { +type jsiiProxy_ReferenceEnumFromScopedPackage struct { _ byte // padding } -func (r *referenceEnumFromScopedPackage_jsiiProxy) Foo() scopejsiicalclib.EnumFromScopedModule { +func (j *jsiiProxy_ReferenceEnumFromScopedPackage) Foo() scopejsiicalclib.EnumFromScopedModule { var returns scopejsiicalclib.EnumFromScopedModule _jsii_.Get( - r, + j, "foo", &returns, ) @@ -10589,28 +10589,28 @@ func (r *referenceEnumFromScopedPackage_jsiiProxy) Foo() scopejsiicalclib.EnumFr func NewReferenceEnumFromScopedPackage() ReferenceEnumFromScopedPackage { _init_.Initialize() - r := referenceEnumFromScopedPackage_jsiiProxy{} + j := jsiiProxy_ReferenceEnumFromScopedPackage{} _jsii_.Create( "jsii-calc.ReferenceEnumFromScopedPackage", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &r, + &j, ) - return &r + return &j } -func (r *referenceEnumFromScopedPackage_jsiiProxy) SetFoo(val scopejsiicalclib.EnumFromScopedModule) { +func (j *jsiiProxy_ReferenceEnumFromScopedPackage) SetFoo(val scopejsiicalclib.EnumFromScopedModule) { _jsii_.Set( - r, + j, "foo", val, ) } -func (r *referenceEnumFromScopedPackage_jsiiProxy) LoadFoo() scopejsiicalclib.EnumFromScopedModule { +func (r *jsiiProxy_ReferenceEnumFromScopedPackage) LoadFoo() scopejsiicalclib.EnumFromScopedModule { var returns scopejsiicalclib.EnumFromScopedModule _jsii_.Invoke( @@ -10623,7 +10623,7 @@ func (r *referenceEnumFromScopedPackage_jsiiProxy) LoadFoo() scopejsiicalclib.En return returns } -func (r *referenceEnumFromScopedPackage_jsiiProxy) SaveFoo(value scopejsiicalclib.EnumFromScopedModule) { +func (r *jsiiProxy_ReferenceEnumFromScopedPackage) SaveFoo(value scopejsiicalclib.EnumFromScopedModule) { _jsii_.InvokeVoid( r, "saveFoo", @@ -10641,14 +10641,14 @@ type ReturnsPrivateImplementationOfInterface interface { } // The jsii proxy struct for ReturnsPrivateImplementationOfInterface -type returnsPrivateImplementationOfInterface_jsiiProxy struct { +type jsiiProxy_ReturnsPrivateImplementationOfInterface struct { _ byte // padding } -func (r *returnsPrivateImplementationOfInterface_jsiiProxy) PrivateImplementation() IPrivatelyImplemented { +func (j *jsiiProxy_ReturnsPrivateImplementationOfInterface) PrivateImplementation() IPrivatelyImplemented { var returns IPrivatelyImplemented _jsii_.Get( - r, + j, "privateImplementation", &returns, ) @@ -10659,17 +10659,17 @@ func (r *returnsPrivateImplementationOfInterface_jsiiProxy) PrivateImplementatio func NewReturnsPrivateImplementationOfInterface() ReturnsPrivateImplementationOfInterface { _init_.Initialize() - r := returnsPrivateImplementationOfInterface_jsiiProxy{} + j := jsiiProxy_ReturnsPrivateImplementationOfInterface{} _jsii_.Create( "jsii-calc.ReturnsPrivateImplementationOfInterface", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &r, + &j, ) - return &r + return &j } // This is here to check that we can pass a nested struct into a kwargs by specifying it as an in-line dictionary. @@ -10686,7 +10686,7 @@ type RootStructValidator interface { } // The jsii proxy struct for RootStructValidator -type rootStructValidator_jsiiProxy struct { +type jsiiProxy_RootStructValidator struct { _ byte // padding } @@ -10707,27 +10707,27 @@ type RuntimeTypeChecking interface { } // The jsii proxy struct for RuntimeTypeChecking -type runtimeTypeChecking_jsiiProxy struct { +type jsiiProxy_RuntimeTypeChecking struct { _ byte // padding } func NewRuntimeTypeChecking() RuntimeTypeChecking { _init_.Initialize() - r := runtimeTypeChecking_jsiiProxy{} + j := jsiiProxy_RuntimeTypeChecking{} _jsii_.Create( "jsii-calc.RuntimeTypeChecking", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &r, + &j, ) - return &r + return &j } -func (r *runtimeTypeChecking_jsiiProxy) MethodWithDefaultedArguments(arg1 float64, arg2 string, arg3 string) { +func (r *jsiiProxy_RuntimeTypeChecking) MethodWithDefaultedArguments(arg1 float64, arg2 string, arg3 string) { _jsii_.InvokeVoid( r, "methodWithDefaultedArguments", @@ -10735,7 +10735,7 @@ func (r *runtimeTypeChecking_jsiiProxy) MethodWithDefaultedArguments(arg1 float6 ) } -func (r *runtimeTypeChecking_jsiiProxy) MethodWithOptionalAnyArgument(arg interface{}) { +func (r *jsiiProxy_RuntimeTypeChecking) MethodWithOptionalAnyArgument(arg interface{}) { _jsii_.InvokeVoid( r, "methodWithOptionalAnyArgument", @@ -10744,7 +10744,7 @@ func (r *runtimeTypeChecking_jsiiProxy) MethodWithOptionalAnyArgument(arg interf } // Used to verify verification of number of method arguments. -func (r *runtimeTypeChecking_jsiiProxy) MethodWithOptionalArguments(arg1 float64, arg2 string, arg3 string) { +func (r *jsiiProxy_RuntimeTypeChecking) MethodWithOptionalArguments(arg1 float64, arg2 string, arg3 string) { _jsii_.InvokeVoid( r, "methodWithOptionalArguments", @@ -10770,27 +10770,27 @@ type SingleInstanceTwoTypes interface { } // The jsii proxy struct for SingleInstanceTwoTypes -type singleInstanceTwoTypes_jsiiProxy struct { +type jsiiProxy_SingleInstanceTwoTypes struct { _ byte // padding } func NewSingleInstanceTwoTypes() SingleInstanceTwoTypes { _init_.Initialize() - s := singleInstanceTwoTypes_jsiiProxy{} + j := jsiiProxy_SingleInstanceTwoTypes{} _jsii_.Create( "jsii-calc.SingleInstanceTwoTypes", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } -func (s *singleInstanceTwoTypes_jsiiProxy) Interface1() InbetweenClass { +func (s *jsiiProxy_SingleInstanceTwoTypes) Interface1() InbetweenClass { var returns InbetweenClass _jsii_.Invoke( @@ -10803,7 +10803,7 @@ func (s *singleInstanceTwoTypes_jsiiProxy) Interface1() InbetweenClass { return returns } -func (s *singleInstanceTwoTypes_jsiiProxy) Interface2() IPublicInterface { +func (s *jsiiProxy_SingleInstanceTwoTypes) Interface2() IPublicInterface { var returns IPublicInterface _jsii_.Invoke( @@ -10824,11 +10824,11 @@ type SingletonInt interface { } // The jsii proxy struct for SingletonInt -type singletonInt_jsiiProxy struct { +type jsiiProxy_SingletonInt struct { _ byte // padding } -func (s *singletonInt_jsiiProxy) IsSingletonInt(value float64) bool { +func (s *jsiiProxy_SingletonInt) IsSingletonInt(value float64) bool { var returns bool _jsii_.Invoke( @@ -10856,11 +10856,11 @@ type SingletonString interface { } // The jsii proxy struct for SingletonString -type singletonString_jsiiProxy struct { +type jsiiProxy_SingletonString struct { _ byte // padding } -func (s *singletonString_jsiiProxy) IsSingletonString(value string) bool { +func (s *jsiiProxy_SingletonString) IsSingletonString(value string) bool { var returns bool _jsii_.Invoke( @@ -10889,24 +10889,24 @@ type SomeTypeJsii976 interface { } // The jsii proxy struct for SomeTypeJsii976 -type someTypeJsii976_jsiiProxy struct { +type jsiiProxy_SomeTypeJsii976 struct { _ byte // padding } func NewSomeTypeJsii976() SomeTypeJsii976 { _init_.Initialize() - s := someTypeJsii976_jsiiProxy{} + j := jsiiProxy_SomeTypeJsii976{} _jsii_.Create( "jsii-calc.SomeTypeJsii976", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } func SomeTypeJsii976_ReturnAnonymous() interface{} { @@ -10947,24 +10947,24 @@ type StableClass interface { } // The jsii proxy struct for StableClass -type stableClass_jsiiProxy struct { +type jsiiProxy_StableClass struct { _ byte // padding } -func (s *stableClass_jsiiProxy) MutableProperty() float64 { +func (j *jsiiProxy_StableClass) MutableProperty() float64 { var returns float64 _jsii_.Get( - s, + j, "mutableProperty", &returns, ) return returns } -func (s *stableClass_jsiiProxy) ReadonlyProperty() string { +func (j *jsiiProxy_StableClass) ReadonlyProperty() string { var returns string _jsii_.Get( - s, + j, "readonlyProperty", &returns, ) @@ -10975,28 +10975,28 @@ func (s *stableClass_jsiiProxy) ReadonlyProperty() string { func NewStableClass(readonlyString string, mutableNumber float64) StableClass { _init_.Initialize() - s := stableClass_jsiiProxy{} + j := jsiiProxy_StableClass{} _jsii_.Create( "jsii-calc.StableClass", []interface{}{readonlyString, mutableNumber}, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } -func (s *stableClass_jsiiProxy) SetMutableProperty(val float64) { +func (j *jsiiProxy_StableClass) SetMutableProperty(val float64) { _jsii_.Set( - s, + j, "mutableProperty", val, ) } -func (s *stableClass_jsiiProxy) Method() { +func (s *jsiiProxy_StableClass) Method() { _jsii_.InvokeVoid( s, "method", @@ -11022,7 +11022,7 @@ type StaticContext interface { } // The jsii proxy struct for StaticContext -type staticContext_jsiiProxy struct { +type jsiiProxy_StaticContext struct { _ byte // padding } @@ -11066,8 +11066,8 @@ type StaticHelloChild interface { } // The jsii proxy struct for StaticHelloChild -type staticHelloChild_jsiiProxy struct { - staticHelloParent_jsiiProxy // extends jsii-calc.StaticHelloParent +type jsiiProxy_StaticHelloChild struct { + jsiiProxy_StaticHelloParent // extends jsii-calc.StaticHelloParent } func StaticHelloChild_Method() { @@ -11100,24 +11100,24 @@ type StaticHelloParent interface { } // The jsii proxy struct for StaticHelloParent -type staticHelloParent_jsiiProxy struct { +type jsiiProxy_StaticHelloParent struct { _ byte // padding } func NewStaticHelloParent() StaticHelloParent { _init_.Initialize() - s := staticHelloParent_jsiiProxy{} + j := jsiiProxy_StaticHelloParent{} _jsii_.Create( "jsii-calc.StaticHelloParent", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } func StaticHelloParent_Method() { @@ -11147,14 +11147,14 @@ type Statics interface { } // The jsii proxy struct for Statics -type statics_jsiiProxy struct { +type jsiiProxy_Statics struct { _ byte // padding } -func (s *statics_jsiiProxy) Value() string { +func (j *jsiiProxy_Statics) Value() string { var returns string _jsii_.Get( - s, + j, "value", &returns, ) @@ -11165,17 +11165,17 @@ func (s *statics_jsiiProxy) Value() string { func NewStatics(value string) Statics { _init_.Initialize() - s := statics_jsiiProxy{} + j := jsiiProxy_Statics{} _jsii_.Create( "jsii-calc.Statics", []interface{}{value}, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } // Jsdocs for static method. @@ -11278,7 +11278,7 @@ func Statics_ZooBar() map[string]string { return returns } -func (s *statics_jsiiProxy) JustMethod() string { +func (s *jsiiProxy_Statics) JustMethod() string { var returns string _jsii_.Invoke( @@ -11305,14 +11305,14 @@ type StripInternal interface { } // The jsii proxy struct for StripInternal -type stripInternal_jsiiProxy struct { +type jsiiProxy_StripInternal struct { _ byte // padding } -func (s *stripInternal_jsiiProxy) YouSeeMe() string { +func (j *jsiiProxy_StripInternal) YouSeeMe() string { var returns string _jsii_.Get( - s, + j, "youSeeMe", &returns, ) @@ -11323,22 +11323,22 @@ func (s *stripInternal_jsiiProxy) YouSeeMe() string { func NewStripInternal() StripInternal { _init_.Initialize() - s := stripInternal_jsiiProxy{} + j := jsiiProxy_StripInternal{} _jsii_.Create( "jsii-calc.StripInternal", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } -func (s *stripInternal_jsiiProxy) SetYouSeeMe(val string) { +func (j *jsiiProxy_StripInternal) SetYouSeeMe(val string) { _jsii_.Set( - s, + j, "youSeeMe", val, ) @@ -11371,24 +11371,24 @@ type StructPassing interface { } // The jsii proxy struct for StructPassing -type structPassing_jsiiProxy struct { +type jsiiProxy_StructPassing struct { _ byte // padding } func NewStructPassing() StructPassing { _init_.Initialize() - s := structPassing_jsiiProxy{} + j := jsiiProxy_StructPassing{} _jsii_.Create( "jsii-calc.StructPassing", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } func StructPassing_HowManyVarArgsDidIPass(_positional float64, inputs TopLevelStruct) float64 { @@ -11425,7 +11425,7 @@ type StructUnionConsumer interface { } // The jsii proxy struct for StructUnionConsumer -type structUnionConsumer_jsiiProxy struct { +type jsiiProxy_StructUnionConsumer struct { _ byte // padding } @@ -11482,24 +11482,24 @@ type Sum interface { } // The jsii proxy struct for Sum -type sum_jsiiProxy struct { +type jsiiProxy_Sum struct { composition.CompositeOperation // extends jsii-calc.composition.CompositeOperation } -func (s *sum_jsiiProxy) Expression() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Sum) Expression() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - s, + j, "expression", &returns, ) return returns } -func (s *sum_jsiiProxy) Parts() []scopejsiicalclib.NumericValue { +func (j *jsiiProxy_Sum) Parts() []scopejsiicalclib.NumericValue { var returns []scopejsiicalclib.NumericValue _jsii_.Get( - s, + j, "parts", &returns, ) @@ -11510,22 +11510,22 @@ func (s *sum_jsiiProxy) Parts() []scopejsiicalclib.NumericValue { func NewSum() Sum { _init_.Initialize() - s := sum_jsiiProxy{} + j := jsiiProxy_Sum{} _jsii_.Create( "jsii-calc.Sum", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } -func (s *sum_jsiiProxy) SetParts(val []scopejsiicalclib.NumericValue) { +func (j *jsiiProxy_Sum) SetParts(val []scopejsiicalclib.NumericValue) { _jsii_.Set( - s, + j, "parts", val, ) @@ -11538,24 +11538,24 @@ type SupportsNiceJavaBuilder interface { } // The jsii proxy struct for SupportsNiceJavaBuilder -type supportsNiceJavaBuilder_jsiiProxy struct { - supportsNiceJavaBuilderWithRequiredProps_jsiiProxy // extends jsii-calc.SupportsNiceJavaBuilderWithRequiredProps +type jsiiProxy_SupportsNiceJavaBuilder struct { + jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps // extends jsii-calc.SupportsNiceJavaBuilderWithRequiredProps } -func (s *supportsNiceJavaBuilder_jsiiProxy) Id() float64 { +func (j *jsiiProxy_SupportsNiceJavaBuilder) Id() float64 { var returns float64 _jsii_.Get( - s, + j, "id", &returns, ) return returns } -func (s *supportsNiceJavaBuilder_jsiiProxy) Rest() []string { +func (j *jsiiProxy_SupportsNiceJavaBuilder) Rest() []string { var returns []string _jsii_.Get( - s, + j, "rest", &returns, ) @@ -11566,17 +11566,17 @@ func (s *supportsNiceJavaBuilder_jsiiProxy) Rest() []string { func NewSupportsNiceJavaBuilder(id float64, defaultBar float64, props SupportsNiceJavaBuilderProps, rest string) SupportsNiceJavaBuilder { _init_.Initialize() - s := supportsNiceJavaBuilder_jsiiProxy{} + j := jsiiProxy_SupportsNiceJavaBuilder{} _jsii_.Create( "jsii-calc.SupportsNiceJavaBuilder", []interface{}{id, defaultBar, props, rest}, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } type SupportsNiceJavaBuilderProps struct { @@ -11596,34 +11596,34 @@ type SupportsNiceJavaBuilderWithRequiredProps interface { } // The jsii proxy struct for SupportsNiceJavaBuilderWithRequiredProps -type supportsNiceJavaBuilderWithRequiredProps_jsiiProxy struct { +type jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps struct { _ byte // padding } -func (s *supportsNiceJavaBuilderWithRequiredProps_jsiiProxy) Bar() float64 { +func (j *jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps) Bar() float64 { var returns float64 _jsii_.Get( - s, + j, "bar", &returns, ) return returns } -func (s *supportsNiceJavaBuilderWithRequiredProps_jsiiProxy) Id() float64 { +func (j *jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps) Id() float64 { var returns float64 _jsii_.Get( - s, + j, "id", &returns, ) return returns } -func (s *supportsNiceJavaBuilderWithRequiredProps_jsiiProxy) PropId() string { +func (j *jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps) PropId() string { var returns string _jsii_.Get( - s, + j, "propId", &returns, ) @@ -11634,17 +11634,17 @@ func (s *supportsNiceJavaBuilderWithRequiredProps_jsiiProxy) PropId() string { func NewSupportsNiceJavaBuilderWithRequiredProps(id float64, props SupportsNiceJavaBuilderProps) SupportsNiceJavaBuilderWithRequiredProps { _init_.Initialize() - s := supportsNiceJavaBuilderWithRequiredProps_jsiiProxy{} + j := jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps{} _jsii_.Create( "jsii-calc.SupportsNiceJavaBuilderWithRequiredProps", []interface{}{id, props}, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } type SyncVirtualMethods interface { @@ -11672,64 +11672,64 @@ type SyncVirtualMethods interface { } // The jsii proxy struct for SyncVirtualMethods -type syncVirtualMethods_jsiiProxy struct { +type jsiiProxy_SyncVirtualMethods struct { _ byte // padding } -func (s *syncVirtualMethods_jsiiProxy) A() float64 { +func (j *jsiiProxy_SyncVirtualMethods) A() float64 { var returns float64 _jsii_.Get( - s, + j, "a", &returns, ) return returns } -func (s *syncVirtualMethods_jsiiProxy) CallerIsProperty() float64 { +func (j *jsiiProxy_SyncVirtualMethods) CallerIsProperty() float64 { var returns float64 _jsii_.Get( - s, + j, "callerIsProperty", &returns, ) return returns } -func (s *syncVirtualMethods_jsiiProxy) OtherProperty() string { +func (j *jsiiProxy_SyncVirtualMethods) OtherProperty() string { var returns string _jsii_.Get( - s, + j, "otherProperty", &returns, ) return returns } -func (s *syncVirtualMethods_jsiiProxy) ReadonlyProperty() string { +func (j *jsiiProxy_SyncVirtualMethods) ReadonlyProperty() string { var returns string _jsii_.Get( - s, + j, "readonlyProperty", &returns, ) return returns } -func (s *syncVirtualMethods_jsiiProxy) TheProperty() string { +func (j *jsiiProxy_SyncVirtualMethods) TheProperty() string { var returns string _jsii_.Get( - s, + j, "theProperty", &returns, ) return returns } -func (s *syncVirtualMethods_jsiiProxy) ValueOfOtherProperty() string { +func (j *jsiiProxy_SyncVirtualMethods) ValueOfOtherProperty() string { var returns string _jsii_.Get( - s, + j, "valueOfOtherProperty", &returns, ) @@ -11740,60 +11740,60 @@ func (s *syncVirtualMethods_jsiiProxy) ValueOfOtherProperty() string { func NewSyncVirtualMethods() SyncVirtualMethods { _init_.Initialize() - s := syncVirtualMethods_jsiiProxy{} + j := jsiiProxy_SyncVirtualMethods{} _jsii_.Create( "jsii-calc.SyncVirtualMethods", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &s, + &j, ) - return &s + return &j } -func (s *syncVirtualMethods_jsiiProxy) SetA(val float64) { +func (j *jsiiProxy_SyncVirtualMethods) SetA(val float64) { _jsii_.Set( - s, + j, "a", val, ) } -func (s *syncVirtualMethods_jsiiProxy) SetCallerIsProperty(val float64) { +func (j *jsiiProxy_SyncVirtualMethods) SetCallerIsProperty(val float64) { _jsii_.Set( - s, + j, "callerIsProperty", val, ) } -func (s *syncVirtualMethods_jsiiProxy) SetOtherProperty(val string) { +func (j *jsiiProxy_SyncVirtualMethods) SetOtherProperty(val string) { _jsii_.Set( - s, + j, "otherProperty", val, ) } -func (s *syncVirtualMethods_jsiiProxy) SetTheProperty(val string) { +func (j *jsiiProxy_SyncVirtualMethods) SetTheProperty(val string) { _jsii_.Set( - s, + j, "theProperty", val, ) } -func (s *syncVirtualMethods_jsiiProxy) SetValueOfOtherProperty(val string) { +func (j *jsiiProxy_SyncVirtualMethods) SetValueOfOtherProperty(val string) { _jsii_.Set( - s, + j, "valueOfOtherProperty", val, ) } -func (s *syncVirtualMethods_jsiiProxy) CallerIsAsync() float64 { +func (s *jsiiProxy_SyncVirtualMethods) CallerIsAsync() float64 { var returns float64 _jsii_.Invoke( @@ -11806,7 +11806,7 @@ func (s *syncVirtualMethods_jsiiProxy) CallerIsAsync() float64 { return returns } -func (s *syncVirtualMethods_jsiiProxy) CallerIsMethod() float64 { +func (s *jsiiProxy_SyncVirtualMethods) CallerIsMethod() float64 { var returns float64 _jsii_.Invoke( @@ -11819,7 +11819,7 @@ func (s *syncVirtualMethods_jsiiProxy) CallerIsMethod() float64 { return returns } -func (s *syncVirtualMethods_jsiiProxy) ModifyOtherProperty(value string) { +func (s *jsiiProxy_SyncVirtualMethods) ModifyOtherProperty(value string) { _jsii_.InvokeVoid( s, "modifyOtherProperty", @@ -11827,7 +11827,7 @@ func (s *syncVirtualMethods_jsiiProxy) ModifyOtherProperty(value string) { ) } -func (s *syncVirtualMethods_jsiiProxy) ModifyValueOfTheProperty(value string) { +func (s *jsiiProxy_SyncVirtualMethods) ModifyValueOfTheProperty(value string) { _jsii_.InvokeVoid( s, "modifyValueOfTheProperty", @@ -11835,7 +11835,7 @@ func (s *syncVirtualMethods_jsiiProxy) ModifyValueOfTheProperty(value string) { ) } -func (s *syncVirtualMethods_jsiiProxy) ReadA() float64 { +func (s *jsiiProxy_SyncVirtualMethods) ReadA() float64 { var returns float64 _jsii_.Invoke( @@ -11848,7 +11848,7 @@ func (s *syncVirtualMethods_jsiiProxy) ReadA() float64 { return returns } -func (s *syncVirtualMethods_jsiiProxy) RetrieveOtherProperty() string { +func (s *jsiiProxy_SyncVirtualMethods) RetrieveOtherProperty() string { var returns string _jsii_.Invoke( @@ -11861,7 +11861,7 @@ func (s *syncVirtualMethods_jsiiProxy) RetrieveOtherProperty() string { return returns } -func (s *syncVirtualMethods_jsiiProxy) RetrieveReadOnlyProperty() string { +func (s *jsiiProxy_SyncVirtualMethods) RetrieveReadOnlyProperty() string { var returns string _jsii_.Invoke( @@ -11874,7 +11874,7 @@ func (s *syncVirtualMethods_jsiiProxy) RetrieveReadOnlyProperty() string { return returns } -func (s *syncVirtualMethods_jsiiProxy) RetrieveValueOfTheProperty() string { +func (s *jsiiProxy_SyncVirtualMethods) RetrieveValueOfTheProperty() string { var returns string _jsii_.Invoke( @@ -11887,7 +11887,7 @@ func (s *syncVirtualMethods_jsiiProxy) RetrieveValueOfTheProperty() string { return returns } -func (s *syncVirtualMethods_jsiiProxy) VirtualMethod(n float64) float64 { +func (s *jsiiProxy_SyncVirtualMethods) VirtualMethod(n float64) float64 { var returns float64 _jsii_.Invoke( @@ -11900,7 +11900,7 @@ func (s *syncVirtualMethods_jsiiProxy) VirtualMethod(n float64) float64 { return returns } -func (s *syncVirtualMethods_jsiiProxy) WriteA(value float64) { +func (s *jsiiProxy_SyncVirtualMethods) WriteA(value float64) { _jsii_.InvokeVoid( s, "writeA", @@ -11916,24 +11916,24 @@ type TestStructWithEnum interface { } // The jsii proxy struct for TestStructWithEnum -type testStructWithEnum_jsiiProxy struct { +type jsiiProxy_TestStructWithEnum struct { _ byte // padding } -func (t *testStructWithEnum_jsiiProxy) StructWithFoo() StructWithEnum { +func (j *jsiiProxy_TestStructWithEnum) StructWithFoo() StructWithEnum { var returns StructWithEnum _jsii_.Get( - t, + j, "structWithFoo", &returns, ) return returns } -func (t *testStructWithEnum_jsiiProxy) StructWithFooBar() StructWithEnum { +func (j *jsiiProxy_TestStructWithEnum) StructWithFooBar() StructWithEnum { var returns StructWithEnum _jsii_.Get( - t, + j, "structWithFooBar", &returns, ) @@ -11944,21 +11944,21 @@ func (t *testStructWithEnum_jsiiProxy) StructWithFooBar() StructWithEnum { func NewTestStructWithEnum() TestStructWithEnum { _init_.Initialize() - t := testStructWithEnum_jsiiProxy{} + j := jsiiProxy_TestStructWithEnum{} _jsii_.Create( "jsii-calc.TestStructWithEnum", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &t, + &j, ) - return &t + return &j } // Returns true if \`foo\` is \`StringEnum.A\`. -func (t *testStructWithEnum_jsiiProxy) IsStringEnumA(input StructWithEnum) bool { +func (t *jsiiProxy_TestStructWithEnum) IsStringEnumA(input StructWithEnum) bool { var returns bool _jsii_.Invoke( @@ -11972,7 +11972,7 @@ func (t *testStructWithEnum_jsiiProxy) IsStringEnumA(input StructWithEnum) bool } // Returns true if \`foo\` is \`StringEnum.B\` and \`bar\` is \`AllTypesEnum.THIS_IS_GREAT\`. -func (t *testStructWithEnum_jsiiProxy) IsStringEnumB(input StructWithEnum) bool { +func (t *jsiiProxy_TestStructWithEnum) IsStringEnumB(input StructWithEnum) bool { var returns bool _jsii_.Invoke( @@ -11990,27 +11990,27 @@ type Thrower interface { } // The jsii proxy struct for Thrower -type thrower_jsiiProxy struct { +type jsiiProxy_Thrower struct { _ byte // padding } func NewThrower() Thrower { _init_.Initialize() - t := thrower_jsiiProxy{} + j := jsiiProxy_Thrower{} _jsii_.Create( "jsii-calc.Thrower", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &t, + &j, ) - return &t + return &j } -func (t *thrower_jsiiProxy) ThrowError() { +func (t *jsiiProxy_Thrower) ThrowError() { _jsii_.InvokeVoid( t, "throwError", @@ -12034,7 +12034,7 @@ type UmaskCheck interface { } // The jsii proxy struct for UmaskCheck -type umaskCheck_jsiiProxy struct { +type jsiiProxy_UmaskCheck struct { _ byte // padding } @@ -12061,14 +12061,14 @@ type UnaryOperation interface { } // The jsii proxy struct for UnaryOperation -type unaryOperation_jsiiProxy struct { +type jsiiProxy_UnaryOperation struct { scopejsiicalclib.Operation // extends @scope/jsii-calc-lib.Operation } -func (u *unaryOperation_jsiiProxy) Operand() scopejsiicalclib.NumericValue { +func (j *jsiiProxy_UnaryOperation) Operand() scopejsiicalclib.NumericValue { var returns scopejsiicalclib.NumericValue _jsii_.Get( - u, + j, "operand", &returns, ) @@ -12079,17 +12079,17 @@ func (u *unaryOperation_jsiiProxy) Operand() scopejsiicalclib.NumericValue { func NewUnaryOperation(operand scopejsiicalclib.NumericValue) UnaryOperation { _init_.Initialize() - u := unaryOperation_jsiiProxy{} + j := jsiiProxy_UnaryOperation{} _jsii_.Create( "jsii-calc.UnaryOperation", []interface{}{operand}, []_jsii_.FQN{}, nil, // no overrides - &u, + &j, ) - return &u + return &j } type UnionProperties struct { @@ -12104,14 +12104,14 @@ type UpcasingReflectable interface { } // The jsii proxy struct for UpcasingReflectable -type upcasingReflectable_jsiiProxy struct { +type jsiiProxy_UpcasingReflectable struct { submodule.IReflectable // implements @scope/jsii-calc-lib.submodule.IReflectable } -func (u *upcasingReflectable_jsiiProxy) Entries() []submodule.ReflectableEntry { +func (j *jsiiProxy_UpcasingReflectable) Entries() []submodule.ReflectableEntry { var returns []submodule.ReflectableEntry _jsii_.Get( - u, + j, "entries", &returns, ) @@ -12122,17 +12122,17 @@ func (u *upcasingReflectable_jsiiProxy) Entries() []submodule.ReflectableEntry { func NewUpcasingReflectable(delegate map[string]interface{}) UpcasingReflectable { _init_.Initialize() - u := upcasingReflectable_jsiiProxy{} + j := jsiiProxy_UpcasingReflectable{} _jsii_.Create( "jsii-calc.UpcasingReflectable", []interface{}{delegate}, []_jsii_.FQN{"@scope/jsii-calc-lib.submodule.IReflectable"}, nil, // no overrides - &u, + &j, ) - return &u + return &j } func UpcasingReflectable_Reflector() submodule.Reflector { @@ -12151,27 +12151,27 @@ type UseBundledDependency interface { } // The jsii proxy struct for UseBundledDependency -type useBundledDependency_jsiiProxy struct { +type jsiiProxy_UseBundledDependency struct { _ byte // padding } func NewUseBundledDependency() UseBundledDependency { _init_.Initialize() - u := useBundledDependency_jsiiProxy{} + j := jsiiProxy_UseBundledDependency{} _jsii_.Create( "jsii-calc.UseBundledDependency", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &u, + &j, ) - return &u + return &j } -func (u *useBundledDependency_jsiiProxy) Value() interface{} { +func (u *jsiiProxy_UseBundledDependency) Value() interface{} { var returns interface{} _jsii_.Invoke( @@ -12190,27 +12190,27 @@ type UseCalcBase interface { } // The jsii proxy struct for UseCalcBase -type useCalcBase_jsiiProxy struct { +type jsiiProxy_UseCalcBase struct { _ byte // padding } func NewUseCalcBase() UseCalcBase { _init_.Initialize() - u := useCalcBase_jsiiProxy{} + j := jsiiProxy_UseCalcBase{} _jsii_.Create( "jsii-calc.UseCalcBase", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &u, + &j, ) - return &u + return &j } -func (u *useCalcBase_jsiiProxy) Hello() scopejsiicalcbase.Base { +func (u *jsiiProxy_UseCalcBase) Hello() scopejsiicalcbase.Base { var returns scopejsiicalcbase.Base _jsii_.Invoke( @@ -12231,14 +12231,14 @@ type UsesInterfaceWithProperties interface { } // The jsii proxy struct for UsesInterfaceWithProperties -type usesInterfaceWithProperties_jsiiProxy struct { +type jsiiProxy_UsesInterfaceWithProperties struct { _ byte // padding } -func (u *usesInterfaceWithProperties_jsiiProxy) Obj() IInterfaceWithProperties { +func (j *jsiiProxy_UsesInterfaceWithProperties) Obj() IInterfaceWithProperties { var returns IInterfaceWithProperties _jsii_.Get( - u, + j, "obj", &returns, ) @@ -12249,20 +12249,20 @@ func (u *usesInterfaceWithProperties_jsiiProxy) Obj() IInterfaceWithProperties { func NewUsesInterfaceWithProperties(obj IInterfaceWithProperties) UsesInterfaceWithProperties { _init_.Initialize() - u := usesInterfaceWithProperties_jsiiProxy{} + j := jsiiProxy_UsesInterfaceWithProperties{} _jsii_.Create( "jsii-calc.UsesInterfaceWithProperties", []interface{}{obj}, []_jsii_.FQN{}, nil, // no overrides - &u, + &j, ) - return &u + return &j } -func (u *usesInterfaceWithProperties_jsiiProxy) JustRead() string { +func (u *jsiiProxy_UsesInterfaceWithProperties) JustRead() string { var returns string _jsii_.Invoke( @@ -12275,7 +12275,7 @@ func (u *usesInterfaceWithProperties_jsiiProxy) JustRead() string { return returns } -func (u *usesInterfaceWithProperties_jsiiProxy) ReadStringAndNumber(ext IInterfaceWithPropertiesExtension) string { +func (u *jsiiProxy_UsesInterfaceWithProperties) ReadStringAndNumber(ext IInterfaceWithPropertiesExtension) string { var returns string _jsii_.Invoke( @@ -12288,7 +12288,7 @@ func (u *usesInterfaceWithProperties_jsiiProxy) ReadStringAndNumber(ext IInterfa return returns } -func (u *usesInterfaceWithProperties_jsiiProxy) WriteAndRead(value string) string { +func (u *jsiiProxy_UsesInterfaceWithProperties) WriteAndRead(value string) string { var returns string _jsii_.Invoke( @@ -12306,27 +12306,27 @@ type VariadicInvoker interface { } // The jsii proxy struct for VariadicInvoker -type variadicInvoker_jsiiProxy struct { +type jsiiProxy_VariadicInvoker struct { _ byte // padding } func NewVariadicInvoker(method VariadicMethod) VariadicInvoker { _init_.Initialize() - v := variadicInvoker_jsiiProxy{} + j := jsiiProxy_VariadicInvoker{} _jsii_.Create( "jsii-calc.VariadicInvoker", []interface{}{method}, []_jsii_.FQN{}, nil, // no overrides - &v, + &j, ) - return &v + return &j } -func (v *variadicInvoker_jsiiProxy) AsArray(values float64) []float64 { +func (v *jsiiProxy_VariadicInvoker) AsArray(values float64) []float64 { var returns []float64 _jsii_.Invoke( @@ -12344,27 +12344,27 @@ type VariadicMethod interface { } // The jsii proxy struct for VariadicMethod -type variadicMethod_jsiiProxy struct { +type jsiiProxy_VariadicMethod struct { _ byte // padding } func NewVariadicMethod(prefix float64) VariadicMethod { _init_.Initialize() - v := variadicMethod_jsiiProxy{} + j := jsiiProxy_VariadicMethod{} _jsii_.Create( "jsii-calc.VariadicMethod", []interface{}{prefix}, []_jsii_.FQN{}, nil, // no overrides - &v, + &j, ) - return &v + return &j } -func (v *variadicMethod_jsiiProxy) AsArray(first float64, others float64) []float64 { +func (v *jsiiProxy_VariadicMethod) AsArray(first float64, others float64) []float64 { var returns []float64 _jsii_.Invoke( @@ -12386,27 +12386,27 @@ type VirtualMethodPlayground interface { } // The jsii proxy struct for VirtualMethodPlayground -type virtualMethodPlayground_jsiiProxy struct { +type jsiiProxy_VirtualMethodPlayground struct { _ byte // padding } func NewVirtualMethodPlayground() VirtualMethodPlayground { _init_.Initialize() - v := virtualMethodPlayground_jsiiProxy{} + j := jsiiProxy_VirtualMethodPlayground{} _jsii_.Create( "jsii-calc.VirtualMethodPlayground", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &v, + &j, ) - return &v + return &j } -func (v *virtualMethodPlayground_jsiiProxy) OverrideMeAsync(index float64) float64 { +func (v *jsiiProxy_VirtualMethodPlayground) OverrideMeAsync(index float64) float64 { var returns float64 _jsii_.Invoke( @@ -12419,7 +12419,7 @@ func (v *virtualMethodPlayground_jsiiProxy) OverrideMeAsync(index float64) float return returns } -func (v *virtualMethodPlayground_jsiiProxy) OverrideMeSync(index float64) float64 { +func (v *jsiiProxy_VirtualMethodPlayground) OverrideMeSync(index float64) float64 { var returns float64 _jsii_.Invoke( @@ -12432,7 +12432,7 @@ func (v *virtualMethodPlayground_jsiiProxy) OverrideMeSync(index float64) float6 return returns } -func (v *virtualMethodPlayground_jsiiProxy) ParallelSumAsync(count float64) float64 { +func (v *jsiiProxy_VirtualMethodPlayground) ParallelSumAsync(count float64) float64 { var returns float64 _jsii_.Invoke( @@ -12445,7 +12445,7 @@ func (v *virtualMethodPlayground_jsiiProxy) ParallelSumAsync(count float64) floa return returns } -func (v *virtualMethodPlayground_jsiiProxy) SerialSumAsync(count float64) float64 { +func (v *jsiiProxy_VirtualMethodPlayground) SerialSumAsync(count float64) float64 { var returns float64 _jsii_.Invoke( @@ -12458,7 +12458,7 @@ func (v *virtualMethodPlayground_jsiiProxy) SerialSumAsync(count float64) float6 return returns } -func (v *virtualMethodPlayground_jsiiProxy) SumSync(count float64) float64 { +func (v *jsiiProxy_VirtualMethodPlayground) SumSync(count float64) float64 { var returns float64 _jsii_.Invoke( @@ -12483,14 +12483,14 @@ type VoidCallback interface { } // The jsii proxy struct for VoidCallback -type voidCallback_jsiiProxy struct { +type jsiiProxy_VoidCallback struct { _ byte // padding } -func (v *voidCallback_jsiiProxy) MethodWasCalled() bool { +func (j *jsiiProxy_VoidCallback) MethodWasCalled() bool { var returns bool _jsii_.Get( - v, + j, "methodWasCalled", &returns, ) @@ -12501,20 +12501,20 @@ func (v *voidCallback_jsiiProxy) MethodWasCalled() bool { func NewVoidCallback() VoidCallback { _init_.Initialize() - v := voidCallback_jsiiProxy{} + j := jsiiProxy_VoidCallback{} _jsii_.Create( "jsii-calc.VoidCallback", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &v, + &j, ) - return &v + return &j } -func (v *voidCallback_jsiiProxy) CallMe() { +func (v *jsiiProxy_VoidCallback) CallMe() { _jsii_.InvokeVoid( v, "callMe", @@ -12522,7 +12522,7 @@ func (v *voidCallback_jsiiProxy) CallMe() { ) } -func (v *voidCallback_jsiiProxy) OverrideMe() { +func (v *jsiiProxy_VoidCallback) OverrideMe() { _jsii_.InvokeVoid( v, "overrideMe", @@ -12536,14 +12536,14 @@ type WithPrivatePropertyInConstructor interface { } // The jsii proxy struct for WithPrivatePropertyInConstructor -type withPrivatePropertyInConstructor_jsiiProxy struct { +type jsiiProxy_WithPrivatePropertyInConstructor struct { _ byte // padding } -func (w *withPrivatePropertyInConstructor_jsiiProxy) Success() bool { +func (j *jsiiProxy_WithPrivatePropertyInConstructor) Success() bool { var returns bool _jsii_.Get( - w, + j, "success", &returns, ) @@ -12554,17 +12554,17 @@ func (w *withPrivatePropertyInConstructor_jsiiProxy) Success() bool { func NewWithPrivatePropertyInConstructor(privateField string) WithPrivatePropertyInConstructor { _init_.Initialize() - w := withPrivatePropertyInConstructor_jsiiProxy{} + j := jsiiProxy_WithPrivatePropertyInConstructor{} _jsii_.Create( "jsii-calc.WithPrivatePropertyInConstructor", []interface{}{privateField}, []_jsii_.FQN{}, nil, // no overrides - &w, + &j, ) - return &w + return &j } @@ -12590,10 +12590,10 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "propFromInterface", GoGetter: "PropFromInterface"}, }, func() interface{} { - a := abstractClass_jsiiProxy{} - _jsii_.InitJsiiProxy(&a.abstractClassBase_jsiiProxy) - _jsii_.InitJsiiProxy(&a.iInterfaceImplementedByAbstractClass_jsiiProxy) - return &a + j := jsiiProxy_AbstractClass{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_AbstractClassBase) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IInterfaceImplementedByAbstractClass) + return &j }, ) _jsii_.RegisterClass( @@ -12603,7 +12603,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "abstractProperty", GoGetter: "AbstractProperty"}, }, func() interface{} { - return &abstractClassBase_jsiiProxy{} + return &jsiiProxy_AbstractClassBase{} }, ) _jsii_.RegisterClass( @@ -12615,7 +12615,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "returnAbstractFromProperty", GoGetter: "ReturnAbstractFromProperty"}, }, func() interface{} { - return &abstractClassReturner_jsiiProxy{} + return &jsiiProxy_AbstractClassReturner{} }, ) _jsii_.RegisterClass( @@ -12627,7 +12627,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "workItAll", GoMethod: "WorkItAll"}, }, func() interface{} { - return &abstractSuite_jsiiProxy{} + return &jsiiProxy_AbstractSuite{} }, ) _jsii_.RegisterClass( @@ -12642,9 +12642,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - a := add_jsiiProxy{} - _jsii_.InitJsiiProxy(&a.binaryOperation_jsiiProxy) - return &a + j := jsiiProxy_Add{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_BinaryOperation) + return &j }, ) _jsii_.RegisterClass( @@ -12675,7 +12675,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "unknownProperty", GoGetter: "UnknownProperty"}, }, func() interface{} { - return &allTypes_jsiiProxy{} + return &jsiiProxy_AllTypes{} }, ) _jsii_.RegisterEnum( @@ -12697,7 +12697,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "setFoo", GoMethod: "SetFoo"}, }, func() interface{} { - return &allowedMethodNames_jsiiProxy{} + return &jsiiProxy_AllowedMethodNames{} }, ) _jsii_.RegisterClass( @@ -12708,7 +12708,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "scope", GoGetter: "Scope"}, }, func() interface{} { - return &ambiguousParameters_jsiiProxy{} + return &jsiiProxy_AmbiguousParameters{} }, ) _jsii_.RegisterClass( @@ -12719,9 +12719,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "provideAsInterface", GoMethod: "ProvideAsInterface"}, }, func() interface{} { - a := anonymousImplementationProvider_jsiiProxy{} - _jsii_.InitJsiiProxy(&a.iAnonymousImplementationProvider_jsiiProxy) - return &a + j := jsiiProxy_AnonymousImplementationProvider{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IAnonymousImplementationProvider) + return &j }, ) _jsii_.RegisterClass( @@ -12736,7 +12736,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "overrideMeToo", GoMethod: "OverrideMeToo"}, }, func() interface{} { - return &asyncVirtualMethods_jsiiProxy{} + return &jsiiProxy_AsyncVirtualMethods{} }, ) _jsii_.RegisterClass( @@ -12747,7 +12747,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "methodTwo", GoMethod: "MethodTwo"}, }, func() interface{} { - return &augmentableClass_jsiiProxy{} + return &jsiiProxy_AugmentableClass{} }, ) _jsii_.RegisterClass( @@ -12755,7 +12755,7 @@ func init() { reflect.TypeOf((*BaseJsii976)(nil)).Elem(), nil, // no members func() interface{} { - return &baseJsii976_jsiiProxy{} + return &jsiiProxy_BaseJsii976{} }, ) _jsii_.RegisterClass( @@ -12766,9 +12766,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "rung", GoGetter: "Rung"}, }, func() interface{} { - b := bell_jsiiProxy{} - _jsii_.InitJsiiProxy(&b.iBell_jsiiProxy) - return &b + j := jsiiProxy_Bell{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IBell) + return &j }, ) _jsii_.RegisterClass( @@ -12783,10 +12783,10 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - b := binaryOperation_jsiiProxy{} - _jsii_.InitJsiiProxy(&b.Operation) - _jsii_.InitJsiiProxy(&b.IFriendly) - return &b + j := jsiiProxy_BinaryOperation{} + _jsii_.InitJsiiProxy(&j.Operation) + _jsii_.InitJsiiProxy(&j.IFriendly) + return &j }, ) _jsii_.RegisterClass( @@ -12797,7 +12797,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "giveItBack", GoMethod: "GiveItBack"}, }, func() interface{} { - return &burriedAnonymousObject_jsiiProxy{} + return &jsiiProxy_BurriedAnonymousObject{} }, ) _jsii_.RegisterClass( @@ -12823,9 +12823,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - c := calculator_jsiiProxy{} - _jsii_.InitJsiiProxy(&c.CompositeOperation) - return &c + j := jsiiProxy_Calculator{} + _jsii_.InitJsiiProxy(&j.CompositeOperation) + return &j }, ) _jsii_.RegisterStruct( @@ -12846,9 +12846,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "d", GoGetter: "D"}, }, func() interface{} { - c := classThatImplementsTheInternalInterface_jsiiProxy{} - _jsii_.InitJsiiProxy(&c.iNonInternalInterface_jsiiProxy) - return &c + j := jsiiProxy_ClassThatImplementsTheInternalInterface{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_INonInternalInterface) + return &j }, ) _jsii_.RegisterClass( @@ -12861,9 +12861,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "e", GoGetter: "E"}, }, func() interface{} { - c := classThatImplementsThePrivateInterface_jsiiProxy{} - _jsii_.InitJsiiProxy(&c.iNonInternalInterface_jsiiProxy) - return &c + j := jsiiProxy_ClassThatImplementsThePrivateInterface{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_INonInternalInterface) + return &j }, ) _jsii_.RegisterClass( @@ -12874,7 +12874,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "map", GoGetter: "Map"}, }, func() interface{} { - return &classWithCollections_jsiiProxy{} + return &jsiiProxy_ClassWithCollections{} }, ) _jsii_.RegisterClass( @@ -12882,7 +12882,7 @@ func init() { reflect.TypeOf((*ClassWithDocs)(nil)).Elem(), nil, // no members func() interface{} { - return &classWithDocs_jsiiProxy{} + return &jsiiProxy_ClassWithDocs{} }, ) _jsii_.RegisterClass( @@ -12893,7 +12893,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "int", GoGetter: "Int"}, }, func() interface{} { - return &classWithJavaReservedWords_jsiiProxy{} + return &jsiiProxy_ClassWithJavaReservedWords{} }, ) _jsii_.RegisterClass( @@ -12903,7 +12903,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "mutableObject", GoGetter: "MutableObject"}, }, func() interface{} { - return &classWithMutableObjectLiteralProperty_jsiiProxy{} + return &jsiiProxy_ClassWithMutableObjectLiteralProperty{} }, ) _jsii_.RegisterClass( @@ -12914,9 +12914,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readWriteString", GoGetter: "ReadWriteString"}, }, func() interface{} { - c := classWithPrivateConstructorAndAutomaticProperties_jsiiProxy{} - _jsii_.InitJsiiProxy(&c.iInterfaceWithProperties_jsiiProxy) - return &c + j := jsiiProxy_ClassWithPrivateConstructorAndAutomaticProperties{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IInterfaceWithProperties) + return &j }, ) _jsii_.RegisterClass( @@ -12926,7 +12926,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "unionProperty", GoGetter: "UnionProperty"}, }, func() interface{} { - return &confusingToJackson_jsiiProxy{} + return &jsiiProxy_ConfusingToJackson{} }, ) _jsii_.RegisterStruct( @@ -12938,7 +12938,7 @@ func init() { reflect.TypeOf((*ConstructorPassesThisOut)(nil)).Elem(), nil, // no members func() interface{} { - return &constructorPassesThisOut_jsiiProxy{} + return &jsiiProxy_ConstructorPassesThisOut{} }, ) _jsii_.RegisterClass( @@ -12946,7 +12946,7 @@ func init() { reflect.TypeOf((*Constructors)(nil)).Elem(), nil, // no members func() interface{} { - return &constructors_jsiiProxy{} + return &jsiiProxy_Constructors{} }, ) _jsii_.RegisterClass( @@ -12956,7 +12956,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "workItBaby", GoMethod: "WorkItBaby"}, }, func() interface{} { - return &consumePureInterface_jsiiProxy{} + return &jsiiProxy_ConsumePureInterface{} }, ) _jsii_.RegisterClass( @@ -12969,7 +12969,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "whenTypedAsClass", GoMethod: "WhenTypedAsClass"}, }, func() interface{} { - return &consumerCanRingBell_jsiiProxy{} + return &jsiiProxy_ConsumerCanRingBell{} }, ) _jsii_.RegisterClass( @@ -12980,7 +12980,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "consumeNonInternalInterface", GoMethod: "ConsumeNonInternalInterface"}, }, func() interface{} { - return &consumersOfThisCrazyTypeSystem_jsiiProxy{} + return &jsiiProxy_ConsumersOfThisCrazyTypeSystem{} }, ) _jsii_.RegisterClass( @@ -12992,7 +12992,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "renderMap", GoMethod: "RenderMap"}, }, func() interface{} { - return &dataRenderer_jsiiProxy{} + return &jsiiProxy_DataRenderer{} }, ) _jsii_.RegisterClass( @@ -13002,7 +13002,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "pleaseCompile", GoMethod: "PleaseCompile"}, }, func() interface{} { - return &default_jsiiProxy{} + return &jsiiProxy_Default{} }, ) _jsii_.RegisterClass( @@ -13014,7 +13014,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "arg3", GoGetter: "Arg3"}, }, func() interface{} { - return &defaultedConstructorArgument_jsiiProxy{} + return &jsiiProxy_DefaultedConstructorArgument{} }, ) _jsii_.RegisterClass( @@ -13022,7 +13022,7 @@ func init() { reflect.TypeOf((*Demonstrate982)(nil)).Elem(), nil, // no members func() interface{} { - return &demonstrate982_jsiiProxy{} + return &jsiiProxy_Demonstrate982{} }, ) _jsii_.RegisterClass( @@ -13034,7 +13034,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readonlyProperty", GoGetter: "ReadonlyProperty"}, }, func() interface{} { - return &deprecatedClass_jsiiProxy{} + return &jsiiProxy_DeprecatedClass{} }, ) _jsii_.RegisterEnum( @@ -13078,7 +13078,7 @@ func init() { reflect.TypeOf((*DisappointingCollectionSource)(nil)).Elem(), nil, // no members func() interface{} { - return &disappointingCollectionSource_jsiiProxy{} + return &jsiiProxy_DisappointingCollectionSource{} }, ) _jsii_.RegisterClass( @@ -13090,7 +13090,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "privatePropertyValue", GoMethod: "PrivatePropertyValue"}, }, func() interface{} { - return &doNotOverridePrivates_jsiiProxy{} + return &jsiiProxy_DoNotOverridePrivates{} }, ) _jsii_.RegisterClass( @@ -13100,7 +13100,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "method", GoMethod: "Method"}, }, func() interface{} { - return &doNotRecognizeAnyAsOptional_jsiiProxy{} + return &jsiiProxy_DoNotRecognizeAnyAsOptional{} }, ) _jsii_.RegisterClass( @@ -13111,7 +13111,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hola", GoMethod: "Hola"}, }, func() interface{} { - return &documentedClass_jsiiProxy{} + return &jsiiProxy_DocumentedClass{} }, ) _jsii_.RegisterClass( @@ -13121,7 +13121,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "optionalAndVariadic", GoMethod: "OptionalAndVariadic"}, }, func() interface{} { - return &dontComplainAboutVariadicAfterOptional_jsiiProxy{} + return &jsiiProxy_DontComplainAboutVariadicAfterOptional{} }, ) _jsii_.RegisterClass( @@ -13132,9 +13132,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "next", GoMethod: "Next"}, }, func() interface{} { - d := doubleTrouble_jsiiProxy{} - _jsii_.InitJsiiProxy(&d.iFriendlyRandomGenerator_jsiiProxy) - return &d + j := jsiiProxy_DoubleTrouble{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IFriendlyRandomGenerator) + return &j }, ) _jsii_.RegisterClass( @@ -13145,7 +13145,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "valueStore", GoGetter: "ValueStore"}, }, func() interface{} { - return &dynamicPropertyBearer_jsiiProxy{} + return &jsiiProxy_DynamicPropertyBearer{} }, ) _jsii_.RegisterClass( @@ -13158,9 +13158,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "valueStore", GoGetter: "ValueStore"}, }, func() interface{} { - d := dynamicPropertyBearerChild_jsiiProxy{} - _jsii_.InitJsiiProxy(&d.dynamicPropertyBearer_jsiiProxy) - return &d + j := jsiiProxy_DynamicPropertyBearerChild{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_DynamicPropertyBearer) + return &j }, ) _jsii_.RegisterClass( @@ -13171,7 +13171,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "repeat", GoMethod: "Repeat"}, }, func() interface{} { - return &entropy_jsiiProxy{} + return &jsiiProxy_Entropy{} }, ) _jsii_.RegisterClass( @@ -13179,7 +13179,7 @@ func init() { reflect.TypeOf((*EnumDispenser)(nil)).Elem(), nil, // no members func() interface{} { - return &enumDispenser_jsiiProxy{} + return &jsiiProxy_EnumDispenser{} }, ) _jsii_.RegisterClass( @@ -13187,7 +13187,7 @@ func init() { reflect.TypeOf((*EraseUndefinedHashValues)(nil)).Elem(), nil, // no members func() interface{} { - return &eraseUndefinedHashValues_jsiiProxy{} + return &jsiiProxy_EraseUndefinedHashValues{} }, ) _jsii_.RegisterStruct( @@ -13203,7 +13203,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readonlyProperty", GoGetter: "ReadonlyProperty"}, }, func() interface{} { - return &experimentalClass_jsiiProxy{} + return &jsiiProxy_ExperimentalClass{} }, ) _jsii_.RegisterEnum( @@ -13225,7 +13225,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "success", GoGetter: "Success"}, }, func() interface{} { - return &exportedBaseClass_jsiiProxy{} + return &jsiiProxy_ExportedBaseClass{} }, ) _jsii_.RegisterStruct( @@ -13241,7 +13241,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readonlyProperty", GoGetter: "ReadonlyProperty"}, }, func() interface{} { - return &externalClass_jsiiProxy{} + return &jsiiProxy_ExternalClass{} }, ) _jsii_.RegisterEnum( @@ -13266,7 +13266,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "structLiteral", GoGetter: "StructLiteral"}, }, func() interface{} { - return &giveMeStructs_jsiiProxy{} + return &jsiiProxy_GiveMeStructs{} }, ) _jsii_.RegisterStruct( @@ -13280,7 +13280,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "betterGreeting", GoMethod: "BetterGreeting"}, }, func() interface{} { - return &greetingAugmenter_jsiiProxy{} + return &jsiiProxy_GreetingAugmenter{} }, ) _jsii_.RegisterInterface( @@ -13291,7 +13291,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "provideAsInterface", GoMethod: "ProvideAsInterface"}, }, func() interface{} { - return &iAnonymousImplementationProvider_jsiiProxy{} + return &jsiiProxy_IAnonymousImplementationProvider{} }, ) _jsii_.RegisterInterface( @@ -13302,7 +13302,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "verb", GoMethod: "Verb"}, }, func() interface{} { - return &iAnonymouslyImplementMe_jsiiProxy{} + return &jsiiProxy_IAnonymouslyImplementMe{} }, ) _jsii_.RegisterInterface( @@ -13312,7 +13312,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "a", GoGetter: "A"}, }, func() interface{} { - return &iAnotherPublicInterface_jsiiProxy{} + return &jsiiProxy_IAnotherPublicInterface{} }, ) _jsii_.RegisterInterface( @@ -13322,7 +13322,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "ring", GoMethod: "Ring"}, }, func() interface{} { - return &iBell_jsiiProxy{} + return &jsiiProxy_IBell{} }, ) _jsii_.RegisterInterface( @@ -13332,7 +13332,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "yourTurn", GoMethod: "YourTurn"}, }, func() interface{} { - return &iBellRinger_jsiiProxy{} + return &jsiiProxy_IBellRinger{} }, ) _jsii_.RegisterInterface( @@ -13342,7 +13342,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "yourTurn", GoMethod: "YourTurn"}, }, func() interface{} { - return &iConcreteBellRinger_jsiiProxy{} + return &jsiiProxy_IConcreteBellRinger{} }, ) _jsii_.RegisterInterface( @@ -13353,7 +13353,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "mutableProperty", GoGetter: "MutableProperty"}, }, func() interface{} { - return &iDeprecatedInterface_jsiiProxy{} + return &jsiiProxy_IDeprecatedInterface{} }, ) _jsii_.RegisterInterface( @@ -13364,7 +13364,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "mutableProperty", GoGetter: "MutableProperty"}, }, func() interface{} { - return &iExperimentalInterface_jsiiProxy{} + return &jsiiProxy_IExperimentalInterface{} }, ) _jsii_.RegisterInterface( @@ -13375,7 +13375,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "private", GoGetter: "Private"}, }, func() interface{} { - return &iExtendsPrivateInterface_jsiiProxy{} + return &jsiiProxy_IExtendsPrivateInterface{} }, ) _jsii_.RegisterInterface( @@ -13386,7 +13386,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "mutableProperty", GoGetter: "MutableProperty"}, }, func() interface{} { - return &iExternalInterface_jsiiProxy{} + return &jsiiProxy_IExternalInterface{} }, ) _jsii_.RegisterInterface( @@ -13398,9 +13398,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - i := iFriendlier_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.IFriendly) - return &i + j := jsiiProxy_IFriendlier{} + _jsii_.InitJsiiProxy(&j.IFriendly) + return &j }, ) _jsii_.RegisterInterface( @@ -13411,10 +13411,10 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "next", GoMethod: "Next"}, }, func() interface{} { - i := iFriendlyRandomGenerator_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.IFriendly) - _jsii_.InitJsiiProxy(&i.iRandomNumberGenerator_jsiiProxy) - return &i + j := jsiiProxy_IFriendlyRandomGenerator{} + _jsii_.InitJsiiProxy(&j.IFriendly) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IRandomNumberGenerator) + return &j }, ) _jsii_.RegisterInterface( @@ -13424,7 +13424,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "propFromInterface", GoGetter: "PropFromInterface"}, }, func() interface{} { - return &iInterfaceImplementedByAbstractClass_jsiiProxy{} + return &jsiiProxy_IInterfaceImplementedByAbstractClass{} }, ) _jsii_.RegisterInterface( @@ -13436,9 +13436,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - i := iInterfaceThatShouldNotBeADataType_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.iInterfaceWithMethods_jsiiProxy) - return &i + j := jsiiProxy_IInterfaceThatShouldNotBeADataType{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IInterfaceWithMethods) + return &j }, ) _jsii_.RegisterInterface( @@ -13448,7 +13448,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "visible", GoMethod: "Visible"}, }, func() interface{} { - return &iInterfaceWithInternal_jsiiProxy{} + return &jsiiProxy_IInterfaceWithInternal{} }, ) _jsii_.RegisterInterface( @@ -13459,7 +13459,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - return &iInterfaceWithMethods_jsiiProxy{} + return &jsiiProxy_IInterfaceWithMethods{} }, ) _jsii_.RegisterInterface( @@ -13469,7 +13469,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - return &iInterfaceWithOptionalMethodArguments_jsiiProxy{} + return &jsiiProxy_IInterfaceWithOptionalMethodArguments{} }, ) _jsii_.RegisterInterface( @@ -13480,7 +13480,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readWriteString", GoGetter: "ReadWriteString"}, }, func() interface{} { - return &iInterfaceWithProperties_jsiiProxy{} + return &jsiiProxy_IInterfaceWithProperties{} }, ) _jsii_.RegisterInterface( @@ -13492,9 +13492,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readWriteString", GoGetter: "ReadWriteString"}, }, func() interface{} { - i := iInterfaceWithPropertiesExtension_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.iInterfaceWithProperties_jsiiProxy) - return &i + j := jsiiProxy_IInterfaceWithPropertiesExtension{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IInterfaceWithProperties) + return &j }, ) _jsii_.RegisterInterface( @@ -13508,9 +13508,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "property", GoGetter: "Property"}, }, func() interface{} { - i := ijsii417Derived_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.ijsii417PublicBaseOfBase_jsiiProxy) - return &i + j := jsiiProxy_Ijsii417Derived{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_Ijsii417PublicBaseOfBase) + return &j }, ) _jsii_.RegisterInterface( @@ -13521,7 +13521,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "hasRoot", GoGetter: "HasRoot"}, }, func() interface{} { - return &ijsii417PublicBaseOfBase_jsiiProxy{} + return &jsiiProxy_Ijsii417PublicBaseOfBase{} }, ) _jsii_.RegisterInterface( @@ -13529,7 +13529,7 @@ func init() { reflect.TypeOf((*IJsii487External)(nil)).Elem(), nil, // no members func() interface{} { - return &iJsii487External_jsiiProxy{} + return &jsiiProxy_IJsii487External{} }, ) _jsii_.RegisterInterface( @@ -13537,7 +13537,7 @@ func init() { reflect.TypeOf((*IJsii487External2)(nil)).Elem(), nil, // no members func() interface{} { - return &iJsii487External2_jsiiProxy{} + return &jsiiProxy_IJsii487External2{} }, ) _jsii_.RegisterInterface( @@ -13545,7 +13545,7 @@ func init() { reflect.TypeOf((*IJsii496)(nil)).Elem(), nil, // no members func() interface{} { - return &iJsii496_jsiiProxy{} + return &jsiiProxy_IJsii496{} }, ) _jsii_.RegisterInterface( @@ -13555,7 +13555,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - return &iMutableObjectLiteral_jsiiProxy{} + return &jsiiProxy_IMutableObjectLiteral{} }, ) _jsii_.RegisterInterface( @@ -13567,9 +13567,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "c", GoGetter: "C"}, }, func() interface{} { - i := iNonInternalInterface_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.iAnotherPublicInterface_jsiiProxy) - return &i + j := jsiiProxy_INonInternalInterface{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IAnotherPublicInterface) + return &j }, ) _jsii_.RegisterInterface( @@ -13580,7 +13580,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "wasSet", GoMethod: "WasSet"}, }, func() interface{} { - return &iObjectWithProperty_jsiiProxy{} + return &jsiiProxy_IObjectWithProperty{} }, ) _jsii_.RegisterInterface( @@ -13590,7 +13590,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "optional", GoMethod: "Optional"}, }, func() interface{} { - return &iOptionalMethod_jsiiProxy{} + return &jsiiProxy_IOptionalMethod{} }, ) _jsii_.RegisterInterface( @@ -13600,7 +13600,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "success", GoGetter: "Success"}, }, func() interface{} { - return &iPrivatelyImplemented_jsiiProxy{} + return &jsiiProxy_IPrivatelyImplemented{} }, ) _jsii_.RegisterInterface( @@ -13610,7 +13610,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "bye", GoMethod: "Bye"}, }, func() interface{} { - return &iPublicInterface_jsiiProxy{} + return &jsiiProxy_IPublicInterface{} }, ) _jsii_.RegisterInterface( @@ -13620,7 +13620,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "ciao", GoMethod: "Ciao"}, }, func() interface{} { - return &iPublicInterface2_jsiiProxy{} + return &jsiiProxy_IPublicInterface2{} }, ) _jsii_.RegisterInterface( @@ -13630,7 +13630,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "next", GoMethod: "Next"}, }, func() interface{} { - return &iRandomNumberGenerator_jsiiProxy{} + return &jsiiProxy_IRandomNumberGenerator{} }, ) _jsii_.RegisterInterface( @@ -13640,7 +13640,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "foo", GoGetter: "Foo"}, }, func() interface{} { - return &iReturnJsii976_jsiiProxy{} + return &jsiiProxy_IReturnJsii976{} }, ) _jsii_.RegisterInterface( @@ -13651,7 +13651,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "obtainNumber", GoMethod: "ObtainNumber"}, }, func() interface{} { - return &iReturnsNumber_jsiiProxy{} + return &jsiiProxy_IReturnsNumber{} }, ) _jsii_.RegisterInterface( @@ -13662,7 +13662,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "mutableProperty", GoGetter: "MutableProperty"}, }, func() interface{} { - return &iStableInterface_jsiiProxy{} + return &jsiiProxy_IStableInterface{} }, ) _jsii_.RegisterInterface( @@ -13672,7 +13672,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "returnStruct", GoMethod: "ReturnStruct"}, }, func() interface{} { - return &iStructReturningDelegate_jsiiProxy{} + return &jsiiProxy_IStructReturningDelegate{} }, ) _jsii_.RegisterInterface( @@ -13682,7 +13682,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "iso8601Now", GoMethod: "Iso8601Now"}, }, func() interface{} { - return &iWallClock_jsiiProxy{} + return &jsiiProxy_IWallClock{} }, ) _jsii_.RegisterClass( @@ -13692,7 +13692,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "prop", GoGetter: "Prop"}, }, func() interface{} { - return &implementInternalInterface_jsiiProxy{} + return &jsiiProxy_ImplementInternalInterface{} }, ) _jsii_.RegisterClass( @@ -13702,7 +13702,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - return &implementation_jsiiProxy{} + return &jsiiProxy_Implementation{} }, ) _jsii_.RegisterClass( @@ -13712,9 +13712,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "visible", GoMethod: "Visible"}, }, func() interface{} { - i := implementsInterfaceWithInternal_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.iInterfaceWithInternal_jsiiProxy) - return &i + j := jsiiProxy_ImplementsInterfaceWithInternal{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IInterfaceWithInternal) + return &j }, ) _jsii_.RegisterClass( @@ -13724,9 +13724,9 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "visible", GoMethod: "Visible"}, }, func() interface{} { - i := implementsInterfaceWithInternalSubclass_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.implementsInterfaceWithInternal_jsiiProxy) - return &i + j := jsiiProxy_ImplementsInterfaceWithInternalSubclass{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_ImplementsInterfaceWithInternal) + return &j }, ) _jsii_.RegisterClass( @@ -13736,7 +13736,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "private", GoGetter: "Private"}, }, func() interface{} { - return &implementsPrivateInterface_jsiiProxy{} + return &jsiiProxy_ImplementsPrivateInterface{} }, ) _jsii_.RegisterStruct( @@ -13751,10 +13751,10 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - i := inbetweenClass_jsiiProxy{} - _jsii_.InitJsiiProxy(&i.publicClass_jsiiProxy) - _jsii_.InitJsiiProxy(&i.iPublicInterface2_jsiiProxy) - return &i + j := jsiiProxy_InbetweenClass{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_PublicClass) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IPublicInterface2) + return &j }, ) _jsii_.RegisterClass( @@ -13762,7 +13762,7 @@ func init() { reflect.TypeOf((*InterfaceCollections)(nil)).Elem(), nil, // no members func() interface{} { - return &interfaceCollections_jsiiProxy{} + return &jsiiProxy_InterfaceCollections{} }, ) _jsii_.RegisterClass( @@ -13770,7 +13770,7 @@ func init() { reflect.TypeOf((*InterfacesMaker)(nil)).Elem(), nil, // no members func() interface{} { - return &interfacesMaker_jsiiProxy{} + return &jsiiProxy_InterfacesMaker{} }, ) _jsii_.RegisterClass( @@ -13780,7 +13780,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "myself", GoMethod: "Myself"}, }, func() interface{} { - return &isomorphism_jsiiProxy{} + return &jsiiProxy_Isomorphism{} }, ) _jsii_.RegisterClass( @@ -13788,7 +13788,7 @@ func init() { reflect.TypeOf((*Issue2638)(nil)).Elem(), nil, // no members func() interface{} { - return &issue2638_jsiiProxy{} + return &jsiiProxy_Issue2638{} }, ) _jsii_.RegisterClass( @@ -13796,7 +13796,7 @@ func init() { reflect.TypeOf((*Issue2638B)(nil)).Elem(), nil, // no members func() interface{} { - return &issue2638B_jsiiProxy{} + return &jsiiProxy_Issue2638B{} }, ) _jsii_.RegisterClass( @@ -13810,8 +13810,8 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "property", GoGetter: "Property"}, }, func() interface{} { - j := jsii417Derived_jsiiProxy{} - _jsii_.InitJsiiProxy(&j.jsii417PublicBaseOfBase_jsiiProxy) + j := jsiiProxy_Jsii417Derived{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_Jsii417PublicBaseOfBase) return &j }, ) @@ -13823,7 +13823,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "hasRoot", GoGetter: "HasRoot"}, }, func() interface{} { - return &jsii417PublicBaseOfBase_jsiiProxy{} + return &jsiiProxy_Jsii417PublicBaseOfBase{} }, ) _jsii_.RegisterClass( @@ -13834,7 +13834,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "giveMeFriendlyGenerator", GoMethod: "GiveMeFriendlyGenerator"}, }, func() interface{} { - return &jsObjectLiteralForInterface_jsiiProxy{} + return &jsiiProxy_JsObjectLiteralForInterface{} }, ) _jsii_.RegisterClass( @@ -13844,7 +13844,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "returnLiteral", GoMethod: "ReturnLiteral"}, }, func() interface{} { - return &jsObjectLiteralToNative_jsiiProxy{} + return &jsiiProxy_JsObjectLiteralToNative{} }, ) _jsii_.RegisterClass( @@ -13855,7 +13855,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "propB", GoGetter: "PropB"}, }, func() interface{} { - return &jsObjectLiteralToNativeClass_jsiiProxy{} + return &jsiiProxy_JsObjectLiteralToNativeClass{} }, ) _jsii_.RegisterClass( @@ -13917,7 +13917,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "while", GoGetter: "While"}, }, func() interface{} { - return &javaReservedWords_jsiiProxy{} + return &jsiiProxy_JavaReservedWords{} }, ) _jsii_.RegisterClass( @@ -13925,9 +13925,9 @@ func init() { reflect.TypeOf((*Jsii487Derived)(nil)).Elem(), nil, // no members func() interface{} { - j := jsii487Derived_jsiiProxy{} - _jsii_.InitJsiiProxy(&j.iJsii487External_jsiiProxy) - _jsii_.InitJsiiProxy(&j.iJsii487External2_jsiiProxy) + j := jsiiProxy_Jsii487Derived{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IJsii487External) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IJsii487External2) return &j }, ) @@ -13936,8 +13936,8 @@ func init() { reflect.TypeOf((*Jsii496Derived)(nil)).Elem(), nil, // no members func() interface{} { - j := jsii496Derived_jsiiProxy{} - _jsii_.InitJsiiProxy(&j.iJsii496_jsiiProxy) + j := jsiiProxy_Jsii496Derived{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IJsii496) return &j }, ) @@ -13946,7 +13946,7 @@ func init() { reflect.TypeOf((*JsiiAgent)(nil)).Elem(), nil, // no members func() interface{} { - return &jsiiAgent_jsiiProxy{} + return &jsiiProxy_JsiiAgent{} }, ) _jsii_.RegisterClass( @@ -13954,7 +13954,7 @@ func init() { reflect.TypeOf((*JsonFormatter)(nil)).Elem(), nil, // no members func() interface{} { - return &jsonFormatter_jsiiProxy{} + return &jsiiProxy_JsonFormatter{} }, ) _jsii_.RegisterClass( @@ -13964,16 +13964,16 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "props", GoGetter: "Props"}, }, func() interface{} { - return &levelOne_jsiiProxy{} + return &jsiiProxy_LevelOne{} }, ) _jsii_.RegisterStruct( "jsii-calc.LevelOne.PropBooleanValue", - reflect.TypeOf((*PropBooleanValue)(nil)).Elem(), + reflect.TypeOf((*LevelOne_PropBooleanValue)(nil)).Elem(), ) _jsii_.RegisterStruct( "jsii-calc.LevelOne.PropProperty", - reflect.TypeOf((*PropProperty)(nil)).Elem(), + reflect.TypeOf((*LevelOne_PropProperty)(nil)).Elem(), ) _jsii_.RegisterStruct( "jsii-calc.LevelOneProps", @@ -13991,7 +13991,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "property", GoMethod: "Property"}, }, func() interface{} { - return &methodNamedProperty_jsiiProxy{} + return &jsiiProxy_MethodNamedProperty{} }, ) _jsii_.RegisterClass( @@ -14009,11 +14009,11 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - m := multiply_jsiiProxy{} - _jsii_.InitJsiiProxy(&m.binaryOperation_jsiiProxy) - _jsii_.InitJsiiProxy(&m.iFriendlier_jsiiProxy) - _jsii_.InitJsiiProxy(&m.iRandomNumberGenerator_jsiiProxy) - return &m + j := jsiiProxy_Multiply{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_BinaryOperation) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IFriendlier) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IRandomNumberGenerator) + return &j }, ) _jsii_.RegisterClass( @@ -14029,10 +14029,10 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - n := negate_jsiiProxy{} - _jsii_.InitJsiiProxy(&n.unaryOperation_jsiiProxy) - _jsii_.InitJsiiProxy(&n.iFriendlier_jsiiProxy) - return &n + j := jsiiProxy_Negate{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_UnaryOperation) + _jsii_.InitJsiiProxy(&j.jsiiProxy_IFriendlier) + return &j }, ) _jsii_.RegisterClass( @@ -14040,7 +14040,7 @@ func init() { reflect.TypeOf((*NestedClassInstance)(nil)).Elem(), nil, // no members func() interface{} { - return &nestedClassInstance_jsiiProxy{} + return &jsiiProxy_NestedClassInstance{} }, ) _jsii_.RegisterStruct( @@ -14057,7 +14057,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "osPlatform", GoGetter: "OsPlatform"}, }, func() interface{} { - return &nodeStandardLibrary_jsiiProxy{} + return &jsiiProxy_NodeStandardLibrary{} }, ) _jsii_.RegisterClass( @@ -14070,7 +14070,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "verifyPropertyIsUndefined", GoMethod: "VerifyPropertyIsUndefined"}, }, func() interface{} { - return &nullShouldBeTreatedAsUndefined_jsiiProxy{} + return &jsiiProxy_NullShouldBeTreatedAsUndefined{} }, ) _jsii_.RegisterStruct( @@ -14086,7 +14086,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "nextTimes100", GoMethod: "NextTimes100"}, }, func() interface{} { - return &numberGenerator_jsiiProxy{} + return &jsiiProxy_NumberGenerator{} }, ) _jsii_.RegisterClass( @@ -14097,7 +14097,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "sumFromMap", GoMethod: "SumFromMap"}, }, func() interface{} { - return &objectRefsInCollections_jsiiProxy{} + return &jsiiProxy_ObjectRefsInCollections{} }, ) _jsii_.RegisterClass( @@ -14105,7 +14105,7 @@ func init() { reflect.TypeOf((*ObjectWithPropertyProvider)(nil)).Elem(), nil, // no members func() interface{} { - return &objectWithPropertyProvider_jsiiProxy{} + return &jsiiProxy_ObjectWithPropertyProvider{} }, ) _jsii_.RegisterClass( @@ -14115,7 +14115,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "doAThing", GoMethod: "DoAThing"}, }, func() interface{} { - return &old_jsiiProxy{} + return &jsiiProxy_Old{} }, ) _jsii_.RegisterClass( @@ -14126,7 +14126,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "invokeWithoutOptional", GoMethod: "InvokeWithoutOptional"}, }, func() interface{} { - return &optionalArgumentInvoker_jsiiProxy{} + return &jsiiProxy_OptionalArgumentInvoker{} }, ) _jsii_.RegisterClass( @@ -14138,7 +14138,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "arg3", GoGetter: "Arg3"}, }, func() interface{} { - return &optionalConstructorArgument_jsiiProxy{} + return &jsiiProxy_OptionalConstructorArgument{} }, ) _jsii_.RegisterStruct( @@ -14153,7 +14153,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "parameterWasUndefined", GoGetter: "ParameterWasUndefined"}, }, func() interface{} { - return &optionalStructConsumer_jsiiProxy{} + return &jsiiProxy_OptionalStructConsumer{} }, ) _jsii_.RegisterClass( @@ -14167,7 +14167,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "valueFromProtected", GoMethod: "ValueFromProtected"}, }, func() interface{} { - return &overridableProtectedMember_jsiiProxy{} + return &jsiiProxy_OverridableProtectedMember{} }, ) _jsii_.RegisterClass( @@ -14177,7 +14177,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "test", GoMethod: "Test"}, }, func() interface{} { - return &overrideReturnsObject_jsiiProxy{} + return &jsiiProxy_OverrideReturnsObject{} }, ) _jsii_.RegisterStruct( @@ -14191,7 +14191,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "consumePartiallyInitializedThis", GoMethod: "ConsumePartiallyInitializedThis"}, }, func() interface{} { - return &partiallyInitializedThisConsumer_jsiiProxy{} + return &jsiiProxy_PartiallyInitializedThisConsumer{} }, ) _jsii_.RegisterClass( @@ -14201,7 +14201,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "sayHello", GoMethod: "SayHello"}, }, func() interface{} { - return &polymorphism_jsiiProxy{} + return &jsiiProxy_Polymorphism{} }, ) _jsii_.RegisterClass( @@ -14219,9 +14219,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - p := power_jsiiProxy{} - _jsii_.InitJsiiProxy(&p.CompositeOperation) - return &p + j := jsiiProxy_Power{} + _jsii_.InitJsiiProxy(&j.CompositeOperation) + return &j }, ) _jsii_.RegisterClass( @@ -14232,7 +14232,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "yetAnoterOne", GoGetter: "YetAnoterOne"}, }, func() interface{} { - return &propertyNamedProperty_jsiiProxy{} + return &jsiiProxy_PropertyNamedProperty{} }, ) _jsii_.RegisterClass( @@ -14242,7 +14242,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - return &publicClass_jsiiProxy{} + return &jsiiProxy_PublicClass{} }, ) _jsii_.RegisterClass( @@ -14283,7 +14283,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "yield", GoMethod: "Yield"}, }, func() interface{} { - return &pythonReservedWords_jsiiProxy{} + return &jsiiProxy_PythonReservedWords{} }, ) _jsii_.RegisterClass( @@ -14295,7 +14295,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "saveFoo", GoMethod: "SaveFoo"}, }, func() interface{} { - return &referenceEnumFromScopedPackage_jsiiProxy{} + return &jsiiProxy_ReferenceEnumFromScopedPackage{} }, ) _jsii_.RegisterClass( @@ -14305,7 +14305,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "privateImplementation", GoGetter: "PrivateImplementation"}, }, func() interface{} { - return &returnsPrivateImplementationOfInterface_jsiiProxy{} + return &jsiiProxy_ReturnsPrivateImplementationOfInterface{} }, ) _jsii_.RegisterStruct( @@ -14317,7 +14317,7 @@ func init() { reflect.TypeOf((*RootStructValidator)(nil)).Elem(), nil, // no members func() interface{} { - return &rootStructValidator_jsiiProxy{} + return &jsiiProxy_RootStructValidator{} }, ) _jsii_.RegisterClass( @@ -14329,7 +14329,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "methodWithOptionalArguments", GoMethod: "MethodWithOptionalArguments"}, }, func() interface{} { - return &runtimeTypeChecking_jsiiProxy{} + return &jsiiProxy_RuntimeTypeChecking{} }, ) _jsii_.RegisterStruct( @@ -14344,7 +14344,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "interface2", GoMethod: "Interface2"}, }, func() interface{} { - return &singleInstanceTwoTypes_jsiiProxy{} + return &jsiiProxy_SingleInstanceTwoTypes{} }, ) _jsii_.RegisterClass( @@ -14354,7 +14354,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "isSingletonInt", GoMethod: "IsSingletonInt"}, }, func() interface{} { - return &singletonInt_jsiiProxy{} + return &jsiiProxy_SingletonInt{} }, ) _jsii_.RegisterEnum( @@ -14371,7 +14371,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "isSingletonString", GoMethod: "IsSingletonString"}, }, func() interface{} { - return &singletonString_jsiiProxy{} + return &jsiiProxy_SingletonString{} }, ) _jsii_.RegisterEnum( @@ -14390,7 +14390,7 @@ func init() { reflect.TypeOf((*SomeTypeJsii976)(nil)).Elem(), nil, // no members func() interface{} { - return &someTypeJsii976_jsiiProxy{} + return &jsiiProxy_SomeTypeJsii976{} }, ) _jsii_.RegisterClass( @@ -14402,7 +14402,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "readonlyProperty", GoGetter: "ReadonlyProperty"}, }, func() interface{} { - return &stableClass_jsiiProxy{} + return &jsiiProxy_StableClass{} }, ) _jsii_.RegisterEnum( @@ -14422,7 +14422,7 @@ func init() { reflect.TypeOf((*StaticContext)(nil)).Elem(), nil, // no members func() interface{} { - return &staticContext_jsiiProxy{} + return &jsiiProxy_StaticContext{} }, ) _jsii_.RegisterClass( @@ -14430,9 +14430,9 @@ func init() { reflect.TypeOf((*StaticHelloChild)(nil)).Elem(), nil, // no members func() interface{} { - s := staticHelloChild_jsiiProxy{} - _jsii_.InitJsiiProxy(&s.staticHelloParent_jsiiProxy) - return &s + j := jsiiProxy_StaticHelloChild{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_StaticHelloParent) + return &j }, ) _jsii_.RegisterClass( @@ -14440,7 +14440,7 @@ func init() { reflect.TypeOf((*StaticHelloParent)(nil)).Elem(), nil, // no members func() interface{} { - return &staticHelloParent_jsiiProxy{} + return &jsiiProxy_StaticHelloParent{} }, ) _jsii_.RegisterClass( @@ -14451,7 +14451,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - return &statics_jsiiProxy{} + return &jsiiProxy_Statics{} }, ) _jsii_.RegisterEnum( @@ -14470,7 +14470,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "youSeeMe", GoGetter: "YouSeeMe"}, }, func() interface{} { - return &stripInternal_jsiiProxy{} + return &jsiiProxy_StripInternal{} }, ) _jsii_.RegisterStruct( @@ -14490,7 +14490,7 @@ func init() { reflect.TypeOf((*StructPassing)(nil)).Elem(), nil, // no members func() interface{} { - return &structPassing_jsiiProxy{} + return &jsiiProxy_StructPassing{} }, ) _jsii_.RegisterClass( @@ -14498,7 +14498,7 @@ func init() { reflect.TypeOf((*StructUnionConsumer)(nil)).Elem(), nil, // no members func() interface{} { - return &structUnionConsumer_jsiiProxy{} + return &jsiiProxy_StructUnionConsumer{} }, ) _jsii_.RegisterStruct( @@ -14523,9 +14523,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - s := sum_jsiiProxy{} - _jsii_.InitJsiiProxy(&s.CompositeOperation) - return &s + j := jsiiProxy_Sum{} + _jsii_.InitJsiiProxy(&j.CompositeOperation) + return &j }, ) _jsii_.RegisterClass( @@ -14538,9 +14538,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "rest", GoGetter: "Rest"}, }, func() interface{} { - s := supportsNiceJavaBuilder_jsiiProxy{} - _jsii_.InitJsiiProxy(&s.supportsNiceJavaBuilderWithRequiredProps_jsiiProxy) - return &s + j := jsiiProxy_SupportsNiceJavaBuilder{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps) + return &j }, ) _jsii_.RegisterStruct( @@ -14556,7 +14556,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "propId", GoGetter: "PropId"}, }, func() interface{} { - return &supportsNiceJavaBuilderWithRequiredProps_jsiiProxy{} + return &jsiiProxy_SupportsNiceJavaBuilderWithRequiredProps{} }, ) _jsii_.RegisterClass( @@ -14581,7 +14581,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "writeA", GoMethod: "WriteA"}, }, func() interface{} { - return &syncVirtualMethods_jsiiProxy{} + return &jsiiProxy_SyncVirtualMethods{} }, ) _jsii_.RegisterClass( @@ -14594,7 +14594,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "structWithFooBar", GoGetter: "StructWithFooBar"}, }, func() interface{} { - return &testStructWithEnum_jsiiProxy{} + return &jsiiProxy_TestStructWithEnum{} }, ) _jsii_.RegisterClass( @@ -14604,7 +14604,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "throwError", GoMethod: "ThrowError"}, }, func() interface{} { - return &thrower_jsiiProxy{} + return &jsiiProxy_Thrower{} }, ) _jsii_.RegisterStruct( @@ -14616,7 +14616,7 @@ func init() { reflect.TypeOf((*UmaskCheck)(nil)).Elem(), nil, // no members func() interface{} { - return &umaskCheck_jsiiProxy{} + return &jsiiProxy_UmaskCheck{} }, ) _jsii_.RegisterClass( @@ -14629,9 +14629,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "value", GoGetter: "Value"}, }, func() interface{} { - u := unaryOperation_jsiiProxy{} - _jsii_.InitJsiiProxy(&u.Operation) - return &u + j := jsiiProxy_UnaryOperation{} + _jsii_.InitJsiiProxy(&j.Operation) + return &j }, ) _jsii_.RegisterStruct( @@ -14645,9 +14645,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "entries", GoGetter: "Entries"}, }, func() interface{} { - u := upcasingReflectable_jsiiProxy{} - _jsii_.InitJsiiProxy(&u.IReflectable) - return &u + j := jsiiProxy_UpcasingReflectable{} + _jsii_.InitJsiiProxy(&j.IReflectable) + return &j }, ) _jsii_.RegisterClass( @@ -14657,7 +14657,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "value", GoMethod: "Value"}, }, func() interface{} { - return &useBundledDependency_jsiiProxy{} + return &jsiiProxy_UseBundledDependency{} }, ) _jsii_.RegisterClass( @@ -14667,7 +14667,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "hello", GoMethod: "Hello"}, }, func() interface{} { - return &useCalcBase_jsiiProxy{} + return &jsiiProxy_UseCalcBase{} }, ) _jsii_.RegisterClass( @@ -14680,7 +14680,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "writeAndRead", GoMethod: "WriteAndRead"}, }, func() interface{} { - return &usesInterfaceWithProperties_jsiiProxy{} + return &jsiiProxy_UsesInterfaceWithProperties{} }, ) _jsii_.RegisterClass( @@ -14690,7 +14690,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "asArray", GoMethod: "AsArray"}, }, func() interface{} { - return &variadicInvoker_jsiiProxy{} + return &jsiiProxy_VariadicInvoker{} }, ) _jsii_.RegisterClass( @@ -14700,7 +14700,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "asArray", GoMethod: "AsArray"}, }, func() interface{} { - return &variadicMethod_jsiiProxy{} + return &jsiiProxy_VariadicMethod{} }, ) _jsii_.RegisterClass( @@ -14714,7 +14714,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "sumSync", GoMethod: "SumSync"}, }, func() interface{} { - return &virtualMethodPlayground_jsiiProxy{} + return &jsiiProxy_VirtualMethodPlayground{} }, ) _jsii_.RegisterClass( @@ -14726,7 +14726,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "overrideMe", GoMethod: "OverrideMe"}, }, func() interface{} { - return &voidCallback_jsiiProxy{} + return &jsiiProxy_VoidCallback{} }, ) _jsii_.RegisterClass( @@ -14736,7 +14736,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "success", GoGetter: "Success"}, }, func() interface{} { - return &withPrivatePropertyInConstructor_jsiiProxy{} + return &jsiiProxy_WithPrivatePropertyInConstructor{} }, ) } @@ -14763,27 +14763,27 @@ type TypeFromSub1 interface { } // The jsii proxy struct for TypeFromSub1 -type typeFromSub1_jsiiProxy struct { +type jsiiProxy_TypeFromSub1 struct { _ byte // padding } func NewTypeFromSub1() TypeFromSub1 { _init_.Initialize() - t := typeFromSub1_jsiiProxy{} + j := jsiiProxy_TypeFromSub1{} _jsii_.Create( "jsii-calc.nodirect.sub1.TypeFromSub1", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &t, + &j, ) - return &t + return &j } -func (t *typeFromSub1_jsiiProxy) Sub1() string { +func (t *jsiiProxy_TypeFromSub1) Sub1() string { var returns string _jsii_.Invoke( @@ -14816,7 +14816,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "sub1", GoMethod: "Sub1"}, }, func() interface{} { - return &typeFromSub1_jsiiProxy{} + return &jsiiProxy_TypeFromSub1{} }, ) } @@ -14836,27 +14836,27 @@ type TypeFromSub2 interface { } // The jsii proxy struct for TypeFromSub2 -type typeFromSub2_jsiiProxy struct { +type jsiiProxy_TypeFromSub2 struct { _ byte // padding } func NewTypeFromSub2() TypeFromSub2 { _init_.Initialize() - t := typeFromSub2_jsiiProxy{} + j := jsiiProxy_TypeFromSub2{} _jsii_.Create( "jsii-calc.nodirect.sub2.TypeFromSub2", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &t, + &j, ) - return &t + return &j } -func (t *typeFromSub2_jsiiProxy) Sub2() string { +func (t *jsiiProxy_TypeFromSub2) Sub2() string { var returns string _jsii_.Invoke( @@ -14889,7 +14889,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "sub2", GoMethod: "Sub2"}, }, func() interface{} { - return &typeFromSub2_jsiiProxy{} + return &jsiiProxy_TypeFromSub2{} }, ) } @@ -14909,7 +14909,7 @@ type OnlyStaticMethods interface { } // The jsii proxy struct for OnlyStaticMethods -type onlyStaticMethods_jsiiProxy struct { +type jsiiProxy_OnlyStaticMethods struct { _ byte // padding } @@ -14946,7 +14946,7 @@ func init() { reflect.TypeOf((*OnlyStaticMethods)(nil)).Elem(), nil, // no members func() interface{} { - return &onlyStaticMethods_jsiiProxy{} + return &jsiiProxy_OnlyStaticMethods{} }, ) } @@ -14967,14 +14967,14 @@ type ClassWithSelf interface { } // The jsii proxy struct for ClassWithSelf -type classWithSelf_jsiiProxy struct { +type jsiiProxy_ClassWithSelf struct { _ byte // padding } -func (c *classWithSelf_jsiiProxy) Self() string { +func (j *jsiiProxy_ClassWithSelf) Self() string { var returns string _jsii_.Get( - c, + j, "self", &returns, ) @@ -14985,20 +14985,20 @@ func (c *classWithSelf_jsiiProxy) Self() string { func NewClassWithSelf(self string) ClassWithSelf { _init_.Initialize() - c := classWithSelf_jsiiProxy{} + j := jsiiProxy_ClassWithSelf{} _jsii_.Create( "jsii-calc.PythonSelf.ClassWithSelf", []interface{}{self}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } -func (c *classWithSelf_jsiiProxy) Method(self float64) string { +func (c *jsiiProxy_ClassWithSelf) Method(self float64) string { var returns string _jsii_.Invoke( @@ -15016,14 +15016,14 @@ type ClassWithSelfKwarg interface { } // The jsii proxy struct for ClassWithSelfKwarg -type classWithSelfKwarg_jsiiProxy struct { +type jsiiProxy_ClassWithSelfKwarg struct { _ byte // padding } -func (c *classWithSelfKwarg_jsiiProxy) Props() StructWithSelf { +func (j *jsiiProxy_ClassWithSelfKwarg) Props() StructWithSelf { var returns StructWithSelf _jsii_.Get( - c, + j, "props", &returns, ) @@ -15034,17 +15034,17 @@ func (c *classWithSelfKwarg_jsiiProxy) Props() StructWithSelf { func NewClassWithSelfKwarg(props StructWithSelf) ClassWithSelfKwarg { _init_.Initialize() - c := classWithSelfKwarg_jsiiProxy{} + j := jsiiProxy_ClassWithSelfKwarg{} _jsii_.Create( "jsii-calc.PythonSelf.ClassWithSelfKwarg", []interface{}{props}, []_jsii_.FQN{}, nil, // no overrides - &c, + &j, ) - return &c + return &j } type IInterfaceWithSelf interface { @@ -15052,11 +15052,11 @@ type IInterfaceWithSelf interface { } // The jsii proxy for IInterfaceWithSelf -type iInterfaceWithSelf_jsiiProxy struct { +type jsiiProxy_IInterfaceWithSelf struct { _ byte // padding } -func (i *iInterfaceWithSelf_jsiiProxy) Method(self float64) string { +func (i *jsiiProxy_IInterfaceWithSelf) Method(self float64) string { var returns string _jsii_.Invoke( @@ -15094,7 +15094,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "self", GoGetter: "Self"}, }, func() interface{} { - return &classWithSelf_jsiiProxy{} + return &jsiiProxy_ClassWithSelf{} }, ) _jsii_.RegisterClass( @@ -15104,7 +15104,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "props", GoGetter: "Props"}, }, func() interface{} { - return &classWithSelfKwarg_jsiiProxy{} + return &jsiiProxy_ClassWithSelfKwarg{} }, ) _jsii_.RegisterInterface( @@ -15114,7 +15114,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "method", GoMethod: "Method"}, }, func() interface{} { - return &iInterfaceWithSelf_jsiiProxy{} + return &jsiiProxy_IInterfaceWithSelf{} }, ) _jsii_.RegisterStruct( @@ -15183,24 +15183,24 @@ type InnerClass interface { } // The jsii proxy struct for InnerClass -type innerClass_jsiiProxy struct { +type jsiiProxy_InnerClass struct { _ byte // padding } func NewInnerClass() InnerClass { _init_.Initialize() - i := innerClass_jsiiProxy{} + j := jsiiProxy_InnerClass{} _jsii_.Create( "jsii-calc.submodule.child.InnerClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &i, + &j, ) - return &i + return &j } func InnerClass_StaticProp() SomeStruct { @@ -15234,14 +15234,14 @@ type OuterClass interface { } // The jsii proxy struct for OuterClass -type outerClass_jsiiProxy struct { +type jsiiProxy_OuterClass struct { _ byte // padding } -func (o *outerClass_jsiiProxy) InnerClass() InnerClass { +func (j *jsiiProxy_OuterClass) InnerClass() InnerClass { var returns InnerClass _jsii_.Get( - o, + j, "innerClass", &returns, ) @@ -15252,17 +15252,17 @@ func (o *outerClass_jsiiProxy) InnerClass() InnerClass { func NewOuterClass() OuterClass { _init_.Initialize() - o := outerClass_jsiiProxy{} + j := jsiiProxy_OuterClass{} _jsii_.Create( "jsii-calc.submodule.child.OuterClass", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &o, + &j, ) - return &o + return &j } type SomeEnum string @@ -15313,7 +15313,7 @@ func init() { reflect.TypeOf((*InnerClass)(nil)).Elem(), nil, // no members func() interface{} { - return &innerClass_jsiiProxy{} + return &jsiiProxy_InnerClass{} }, ) _jsii_.RegisterStruct( @@ -15327,7 +15327,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "innerClass", GoGetter: "InnerClass"}, }, func() interface{} { - return &outerClass_jsiiProxy{} + return &jsiiProxy_OuterClass{} }, ) _jsii_.RegisterEnum( @@ -15364,7 +15364,7 @@ type Kwargs interface { } // The jsii proxy struct for Kwargs -type kwargs_jsiiProxy struct { +type jsiiProxy_Kwargs struct { _ byte // padding } @@ -15401,7 +15401,7 @@ func init() { reflect.TypeOf((*Kwargs)(nil)).Elem(), nil, // no members func() interface{} { - return &kwargs_jsiiProxy{} + return &jsiiProxy_Kwargs{} }, ) } @@ -15420,14 +15420,14 @@ type INamespaced interface { } // The jsii proxy for INamespaced -type iNamespaced_jsiiProxy struct { +type jsiiProxy_INamespaced struct { _ byte // padding } -func (i *iNamespaced_jsiiProxy) DefinedAt() string { +func (j *jsiiProxy_INamespaced) DefinedAt() string { var returns string _jsii_.Get( - i, + j, "definedAt", &returns, ) @@ -15454,7 +15454,7 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "definedAt", GoGetter: "DefinedAt"}, }, func() interface{} { - return &iNamespaced_jsiiProxy{} + return &jsiiProxy_INamespaced{} }, ) } @@ -15478,24 +15478,24 @@ type Namespaced interface { } // The jsii proxy struct for Namespaced -type namespaced_jsiiProxy struct { +type jsiiProxy_Namespaced struct { deeplynested.INamespaced // implements jsii-calc.submodule.nested_submodule.deeplyNested.INamespaced } -func (n *namespaced_jsiiProxy) DefinedAt() string { +func (j *jsiiProxy_Namespaced) DefinedAt() string { var returns string _jsii_.Get( - n, + j, "definedAt", &returns, ) return returns } -func (n *namespaced_jsiiProxy) Goodness() child.Goodness { +func (j *jsiiProxy_Namespaced) Goodness() child.Goodness { var returns child.Goodness _jsii_.Get( - n, + j, "goodness", &returns, ) @@ -15524,9 +15524,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "goodness", GoGetter: "Goodness"}, }, func() interface{} { - n := namespaced_jsiiProxy{} - _jsii_.InitJsiiProxy(&n.INamespaced) - return &n + j := jsiiProxy_Namespaced{} + _jsii_.InitJsiiProxy(&j.INamespaced) + return &j }, ) } @@ -15577,27 +15577,27 @@ type ReturnsSpecialParameter interface { } // The jsii proxy struct for ReturnsSpecialParameter -type returnsSpecialParameter_jsiiProxy struct { +type jsiiProxy_ReturnsSpecialParameter struct { _ byte // padding } func NewReturnsSpecialParameter() ReturnsSpecialParameter { _init_.Initialize() - r := returnsSpecialParameter_jsiiProxy{} + j := jsiiProxy_ReturnsSpecialParameter{} _jsii_.Create( "jsii-calc.submodule.returnsparam.ReturnsSpecialParameter", nil /* no parameters */, []_jsii_.FQN{}, nil, // no overrides - &r, + &j, ) - return &r + return &j } -func (r *returnsSpecialParameter_jsiiProxy) ReturnsSpecialParam() param.SpecialParameter { +func (r *jsiiProxy_ReturnsSpecialParameter) ReturnsSpecialParam() param.SpecialParameter { var returns param.SpecialParameter _jsii_.Invoke( @@ -15630,7 +15630,7 @@ func init() { _jsii_.MemberMethod{JsiiMethod: "returnsSpecialParam", GoMethod: "ReturnsSpecialParam"}, }, func() interface{} { - return &returnsSpecialParameter_jsiiProxy{} + return &jsiiProxy_ReturnsSpecialParameter{} }, ) } @@ -15669,54 +15669,54 @@ type MyClass interface { } // The jsii proxy struct for MyClass -type myClass_jsiiProxy struct { +type jsiiProxy_MyClass struct { deeplynested.INamespaced // implements jsii-calc.submodule.nested_submodule.deeplyNested.INamespaced } -func (m *myClass_jsiiProxy) AllTypes() jsiicalc.AllTypes { +func (j *jsiiProxy_MyClass) AllTypes() jsiicalc.AllTypes { var returns jsiicalc.AllTypes _jsii_.Get( - m, + j, "allTypes", &returns, ) return returns } -func (m *myClass_jsiiProxy) Awesomeness() child.Awesomeness { +func (j *jsiiProxy_MyClass) Awesomeness() child.Awesomeness { var returns child.Awesomeness _jsii_.Get( - m, + j, "awesomeness", &returns, ) return returns } -func (m *myClass_jsiiProxy) DefinedAt() string { +func (j *jsiiProxy_MyClass) DefinedAt() string { var returns string _jsii_.Get( - m, + j, "definedAt", &returns, ) return returns } -func (m *myClass_jsiiProxy) Goodness() child.Goodness { +func (j *jsiiProxy_MyClass) Goodness() child.Goodness { var returns child.Goodness _jsii_.Get( - m, + j, "goodness", &returns, ) return returns } -func (m *myClass_jsiiProxy) Props() child.SomeStruct { +func (j *jsiiProxy_MyClass) Props() child.SomeStruct { var returns child.SomeStruct _jsii_.Get( - m, + j, "props", &returns, ) @@ -15727,28 +15727,28 @@ func (m *myClass_jsiiProxy) Props() child.SomeStruct { func NewMyClass(props child.SomeStruct) MyClass { _init_.Initialize() - m := myClass_jsiiProxy{} + j := jsiiProxy_MyClass{} _jsii_.Create( "jsii-calc.submodule.MyClass", []interface{}{props}, []_jsii_.FQN{"jsii-calc.submodule.nested_submodule.deeplyNested.INamespaced"}, nil, // no overrides - &m, + &j, ) - return &m + return &j } -func (m *myClass_jsiiProxy) SetAllTypes(val jsiicalc.AllTypes) { +func (j *jsiiProxy_MyClass) SetAllTypes(val jsiicalc.AllTypes) { _jsii_.Set( - m, + j, "allTypes", val, ) } -func (m *myClass_jsiiProxy) MethodWithSpecialParam(param param.SpecialParameter) string { +func (m *jsiiProxy_MyClass) MethodWithSpecialParam(param param.SpecialParameter) string { var returns string _jsii_.Invoke( @@ -15790,9 +15790,9 @@ func init() { _jsii_.MemberProperty{JsiiProperty: "props", GoGetter: "Props"}, }, func() interface{} { - m := myClass_jsiiProxy{} - _jsii_.InitJsiiProxy(&m.INamespaced) - return &m + j := jsiiProxy_MyClass{} + _jsii_.InitJsiiProxy(&j.INamespaced) + return &j }, ) } diff --git a/packages/jsii-pacmak/test/generated-code/examples.test.ts b/packages/jsii-pacmak/test/generated-code/examples.test.ts new file mode 100644 index 0000000000..54f7451663 --- /dev/null +++ b/packages/jsii-pacmak/test/generated-code/examples.test.ts @@ -0,0 +1,95 @@ +import { AssemblyTargets, SPEC_FILE_NAME } from '@jsii/spec'; +import * as fs from 'fs-extra'; +import * as jsii from 'jsii'; +import * as os from 'os'; +import * as path from 'path'; + +import * as pacmak from '../../lib'; +import { checkTree, TREE } from './harness'; + +const EXAMPLES_ROOT = path.resolve(__dirname, 'examples'); + +for (const name of fs.readdirSync(EXAMPLES_ROOT)) { + const file = path.join(EXAMPLES_ROOT, name); + test(name, async () => { + const source = await fs.readFile(file, 'utf8'); + const compiled = await jsii.compileJsiiForTest(source); + + const targets: AssemblyTargets = { + dotnet: { + namespace: 'Example.Test.Demo', + packageId: 'Example.Test.Demo', + }, + go: { moduleName: 'example.test/demo' }, + java: { + maven: { + groupId: 'example.test', + artifactId: 'demo', + }, + package: 'example.test.demo', + }, + python: { + distName: 'example-test.demo', + module: 'example_test_demo', + }, + }; + + const tmpdir = await fs.mkdtemp( + path.join(os.tmpdir(), 'jsii-pacmak-examples.tests-'), + ); + try { + // Create pretend source tree + await fs.writeJson( + path.join(tmpdir, SPEC_FILE_NAME), + { ...compiled.assembly, targets }, + { + encoding: 'utf8', + spaces: 2, + }, + ); + await fs.writeJson(path.join(tmpdir, 'package.json'), { + name: compiled.assembly.name, + version: compiled.assembly.version, + jsii: { + outdir: 'dist', + targets, + }, + }); + + // Execute pacmak on source tree + const outputDirectory = path.join(tmpdir, 'dist'); + await pacmak.pacmak({ + inputDirectories: [tmpdir], + outputDirectory, + codeOnly: true, + fingerprint: false, + forceSubdirectory: true, + parallel: false, + updateNpmIgnoreFiles: false, + }); + + expect({ + [TREE]: checkTree(outputDirectory, { excludes }), + }).toMatchSnapshot('/'); + } finally { + await fs.remove(tmpdir); + } + }); +} + +const excludedFiles = new Set([ + 'LICENSE', + 'MANIFEST.in', + 'README.md', + 'version', +]); +function excludes(file: string): boolean { + return ( + // Ignore known excluded files, they don't add much value. + excludedFiles.has(path.basename(file)) || + // Ignore the tarballs, they are boring... + file.endsWith('.tgz') || + // Ignore the "js" generated code, because it's boring... + file.split(path.sep)[0] === 'js' + ); +} diff --git a/packages/jsii-pacmak/test/generated-code/examples/nested-types.ts b/packages/jsii-pacmak/test/generated-code/examples/nested-types.ts new file mode 100644 index 0000000000..9f622316a5 --- /dev/null +++ b/packages/jsii-pacmak/test/generated-code/examples/nested-types.ts @@ -0,0 +1,41 @@ +// See: https://github.com/aws/jsii/issues/2649 + +export class Namespace1 { + public foo() { + return; + } +} + +export class Namespace2 { + public foo() { + return; + } +} + +export namespace Namespace1 { + // Effectively Namespace1.Foo + export interface Foo { + readonly bar: string; + } + + // Effectively Namespace1.IBar + export interface IBar { + readonly bar: string; + method(): void; + } +} + +export namespace Namespace2 { + // Effectively Namespace2.Foo + export enum Foo { + BAR, + BAZ, + } + + export namespace Foo { + // Effectively Namespace2.Foo.Final + export class Final { + public readonly done = true; + } + } +} diff --git a/packages/jsii-pacmak/test/generated-code/harness.ts b/packages/jsii-pacmak/test/generated-code/harness.ts index 04e417b97b..1359ddc615 100644 --- a/packages/jsii-pacmak/test/generated-code/harness.ts +++ b/packages/jsii-pacmak/test/generated-code/harness.ts @@ -77,10 +77,17 @@ export function verifyGeneratedCodeFor( export function checkTree( file: string, - root: string = file, + { + root = file, + excludes = (_) => false, + }: { root?: string; excludes?: (file: string) => boolean } = {}, ): TreeStructure | undefined { const stat = tryStat(file); + if (excludes(path.relative(root, file))) { + return undefined; + } + // Normalizing paths so snapshots are identical in Windows, too... const relativeFile = path.relative(root, file).replace(/\\/g, '/'); const snapshotName = `/${relativeFile}`; @@ -106,10 +113,12 @@ export function checkTree( .readdirSync(file) .map((entry) => ({ entry, - subtree: checkTree(path.join(file, entry), root), + subtree: checkTree(path.join(file, entry), { root, excludes }), })) .reduce((tree, { entry, subtree }) => { - tree[entry] = subtree!; + if (subtree != null) { + tree[entry] = subtree; + } return tree; }, {} as { [name: string]: TreeStructure }); diff --git a/packages/jsii-pacmak/tsconfig.json b/packages/jsii-pacmak/tsconfig.json index b1f81b544d..c9343fc788 100644 --- a/packages/jsii-pacmak/tsconfig.json +++ b/packages/jsii-pacmak/tsconfig.json @@ -1,13 +1,12 @@ { "extends": "../../tsconfig-base", - "include": [ - "**/*.ts" - ], - "exclude": ["jest.config.ts"], + "include": ["**/*.ts"], + "exclude": ["jest.config.ts", "test/generated-code/examples/*"], "references": [ { "path": "../@jsii/spec" }, { "path": "../codemaker" }, + { "path": "../jsii" }, { "path": "../jsii-rosetta" }, - { "path": "../jsii-reflect" }, - ], + { "path": "../jsii-reflect" } + ] } diff --git a/packages/jsii-reflect/lib/type.ts b/packages/jsii-reflect/lib/type.ts index 3a3441f236..04d9c1c9ce 100644 --- a/packages/jsii-reflect/lib/type.ts +++ b/packages/jsii-reflect/lib/type.ts @@ -40,6 +40,17 @@ export abstract class Type implements Documentable, SourceLocatable { return this.spec.namespace; } + /** + * The type within which this type is nested (if any). + */ + public get nestingParent(): Type | undefined { + const ns = this.namespace; + if (ns == null) { + return undefined; + } + return this.assembly.tryFindType(`${this.assembly.name}.${ns}`); + } + /** * The simple name of the type (MyClass). */ diff --git a/packages/jsii/lib/helpers.ts b/packages/jsii/lib/helpers.ts index 54778c05e7..8eb45dd07d 100644 --- a/packages/jsii/lib/helpers.ts +++ b/packages/jsii/lib/helpers.ts @@ -35,7 +35,7 @@ export interface HelperCompilationResult { /** * The generated assembly */ - readonly assembly: any; + readonly assembly: spec.Assembly; /** * Generated .js/.d.ts file(s) */ diff --git a/packages/jsii/lib/jsii-diagnostic.ts b/packages/jsii/lib/jsii-diagnostic.ts index d923f59064..f5cbc82064 100644 --- a/packages/jsii/lib/jsii-diagnostic.ts +++ b/packages/jsii/lib/jsii-diagnostic.ts @@ -601,6 +601,20 @@ export class JsiiDiagnostic implements ts.Diagnostic { name: 'language-compatibility/member-name-conflicts-with-type-name', }); + public static readonly JSII_5020_STATIC_MEMBER_CONFLICTS_WITH_NESTED_TYPE = Code.error( + { + code: 5020, + formatter: ( + nestingType: spec.Type, + staticMember: spec.Property | spec.Method | spec.EnumMember, + nestedType: spec.Type, + ) => + `The static member "${nestingType.name}.${staticMember.name}" has the same PascalCased representation as nested type "${nestingType.name}.${nestedType.name}". This would result in invalid code in Go.`, + name: + 'language-compatibility/static-member-name-conflicts-with-nested-type', + }, + ); + ////////////////////////////////////////////////////////////////////////////// // 6000 => 6999 -- RESERVED diff --git a/packages/jsii/lib/validator.ts b/packages/jsii/lib/validator.ts index 993ad6dc74..e6b67de821 100644 --- a/packages/jsii/lib/validator.ts +++ b/packages/jsii/lib/validator.ts @@ -6,6 +6,7 @@ import * as ts from 'typescript'; import { Emitter } from './emitter'; import { JsiiDiagnostic } from './jsii-diagnostic'; +import { getRelatedNode } from './node-bindings'; import { ProjectInfo } from './project-info'; export class Validator implements Emitter { @@ -55,6 +56,7 @@ function _defaultValidations(): ValidationFunction[] { _memberNamesMustNotLookLikeJavaGettersOrSetters, _allTypeReferencesAreValid, _inehritanceDoesNotChangeContracts, + _staticMembersAndNestedTypesMustNotSharePascalCaseName, ]; function _typeNamesMustUsePascalCase( @@ -512,6 +514,53 @@ function _defaultValidations(): ValidationFunction[] { } } } + + function _staticMembersAndNestedTypesMustNotSharePascalCaseName( + _: Validator, + assembly: spec.Assembly, + diagnostic: DiagnosticEmitter, + ) { + for (const nestedType of Object.values(assembly.types ?? {})) { + if (nestedType.namespace == null) { + continue; + } + const nestingType = assembly.types![ + `${assembly.name}.${nestedType.namespace}` + ]; + if (nestingType == null) { + continue; + } + const nestedTypeName = Case.pascal(nestedType.name); + for (const { name, member } of staticMembers(nestingType)) { + if (name === nestedTypeName) { + let diag = JsiiDiagnostic.JSII_5020_STATIC_MEMBER_CONFLICTS_WITH_NESTED_TYPE.create( + getRelatedNode(member)!, + nestingType, + member, + nestedType, + ); + const nestedTypeNode = getRelatedNode(nestedType); + if (nestedTypeNode != null) { + diag = diag.addRelatedInformation( + nestedTypeNode, + 'This is the conflicting nested type declaration', + ); + } + diagnostic(diag); + } + } + } + + function staticMembers(type: spec.Type) { + if (spec.isClassOrInterfaceType(type)) { + return [ + ...(type.methods?.filter((method) => method.static) ?? []), + ...(type.properties?.filter((prop) => prop.static) ?? []), + ].map((member) => ({ name: Case.pascal(member.name), member })); + } + return type.members.map((member) => ({ name: member.name, member })); + } + } } function _allTypes(assm: spec.Assembly): spec.Type[] { diff --git a/packages/jsii/test/__snapshots__/negatives.test.ts.snap b/packages/jsii/test/__snapshots__/negatives.test.ts.snap index 86abaab964..f24de9dab3 100644 --- a/packages/jsii/test/__snapshots__/negatives.test.ts.snap +++ b/packages/jsii/test/__snapshots__/negatives.test.ts.snap @@ -609,6 +609,27 @@ error JSII8002: Method and property (unless they are static readonly) names must `; +exports[`static-nested-conflict 1`] = ` +neg.static-nested-conflict.ts:5:3 - error JSII5020: The static member "ParentClass.nestedStruct" has the same PascalCased representation as nested type "ParentClass.NestedStruct". This would result in invalid code in Go. + +5 public static nestedStruct(): boolean { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +6 return false; + ~~~~~~~~~~~~~~~~~ +7 } + ~~~ + + neg.static-nested-conflict.ts:13:3 + 13 export interface NestedStruct { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 14 readonly field: number; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 15 } + ~~~ + This is the conflicting nested type declaration + +`; + exports[`static-prop-name.1 1`] = ` error JSII8002: Method and property (unless they are static readonly) names must use camelCase. Rename "jsii.MyClass.Prop" to "prop" diff --git a/packages/jsii/test/negatives/neg.static-nested-conflict.ts b/packages/jsii/test/negatives/neg.static-nested-conflict.ts new file mode 100644 index 0000000000..c0ccf38a30 --- /dev/null +++ b/packages/jsii/test/negatives/neg.static-nested-conflict.ts @@ -0,0 +1,16 @@ +// There will be a conflict between the static method and nested type in certain +// languages, including C# and Go, where methods are PascalCased. + +export class ParentClass { + public static nestedStruct(): boolean { + return false; + } + + private constructor() {} +} + +export namespace ParentClass { + export interface NestedStruct { + readonly field: number; + } +}