@furo/open-models 1.5.2 → 1.6.1

package/dist/protoc-gen-open-models/google/protobuf/Any.d.ts

@@ -1,356 +0,0 @@
-import { BYTES, FieldNode, STRING } from '@furo/open-models/dist/index';
-/**
- * @interface IXAny
- *  `Any` contains an arbitrary serialized protocol buffer message along with a
- *  URL that describes the type of the serialized message.
- *
- *  Protobuf library provides support to pack/unpack Any values in the form
- *  of utility functions or additional generated methods of the Any type.
- *
- *  Example 1: Pack and unpack a message in C++.
- *
- *      Foo foo = ...;
- *      Any any;
- *      any.PackFrom(foo);
- *      ...
- *      if (any.UnpackTo(&foo)) {
- *        ...
- *      }
- *
- *  Example 2: Pack and unpack a message in Java.
- *
- *      Foo foo = ...;
- *      Any any = Any.pack(foo);
- *      ...
- *      if (any.is(Foo.class)) {
- *        foo = any.unpack(Foo.class);
- *      }
- *      // or ...
- *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *        foo = any.unpack(Foo.getDefaultInstance());
- *      }
- *
- *   Example 3: Pack and unpack a message in Python.
- *
- *      foo = Foo(...)
- *      any = Any()
- *      any.Pack(foo)
- *      ...
- *      if any.Is(Foo.DESCRIPTOR):
- *        any.Unpack(foo)
- *        ...
- *
- *   Example 4: Pack and unpack a message in Go
- *
- *       foo := &pb.Foo{...}
- *       any, err := anypb.New(foo)
- *       if err != nil {
- *         ...
- *       }
- *       ...
- *       foo := &pb.Foo{}
- *       if err := any.UnmarshalTo(foo); err != nil {
- *         ...
- *       }
- *
- *  The pack methods provided by protobuf library will by default use
- *  'type.googleapis.com/full.type.name' as the type URL and the unpack
- *  methods only use the fully qualified type name after the last '/'
- *  in the type URL, for example "foo.bar.com/x/y.z" will yield type
- *  name "y.z".
- *
- *  JSON
- *  ====
- *  The JSON representation of an `Any` value uses the regular
- *  representation of the deserialized, embedded message, with an
- *  additional field `@type` which contains the type URL. Example:
- *
- *      package google.profile;
- *      message Person {
- *        string first_name = 1;
- *        string last_name = 2;
- *      }
- *
- *      {
- *        "@type": "type.googleapis.com/google.profile.Person",
- *        "firstName": <string>,
- *        "lastName": <string>
- *      }
- *
- *  If the embedded message type is well-known and has a custom JSON
- *  representation, that representation will be embedded adding a field
- *  `value` which holds the custom JSON in addition to the `@type`
- *  field. Example (for message [google.protobuf.Duration][]):
- *
- *      {
- *        "@type": "type.googleapis.com/google.protobuf.Duration",
- *        "value": "1.212s"
- *      }
- *
- */
-export interface IXAny {
-    /**
-     *  A URL/resource name that uniquely identifies the type of the serialized
-     *  protocol buffer message. This string must contain at least
-     *  one "/" character. The last segment of the URL's path must represent
-     *  the fully qualified name of the type (as in
-     *  `path/google.protobuf.Duration`). The name should be in a canonical form
-     *  (e.g., leading "." is not accepted).
-     *
-     *  In practice, teams usually precompile into the binary all types that they
-     *  expect it to use in the context of Any. However, for URLs which use the
-     *  scheme `http`, `https`, or no scheme, one can optionally set up a type
-     *  server that maps type URLs to message definitions as follows:
-     *
-     *  * If no scheme is provided, `https` is assumed.
-     *  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-     *    value in binary format, or produce an error.
-     *  * Applications are allowed to cache lookup results based on the
-     *    URL, or have them precompiled into a binary to avoid any
-     *    lookup. Therefore, binary compatibility needs to be preserved
-     *    on changes to types. (Use versioned type names to manage
-     *    breaking changes.)
-     *
-     *  Note: this functionality is not currently available in the official
-     *  protobuf release, and it is not used for type URLs beginning with
-     *  type.googleapis.com. As of May 2023, there are no widely used type server
-     *  implementations and no plans to implement one.
-     *
-     *  Schemes other than `http`, `https` (or the empty scheme) might be
-     *  used with implementation specific semantics.
-     *
-     */
-    typeUrl?: string;
-    /**
-     *  Must be a valid serialized protocol buffer of the above specified type.
-     */
-    value?: string;
-}
-/**
- * @interface TXAny
- *  `Any` contains an arbitrary serialized protocol buffer message along with a
- *  URL that describes the type of the serialized message.
- *
- *  Protobuf library provides support to pack/unpack Any values in the form
- *  of utility functions or additional generated methods of the Any type.
- *
- *  Example 1: Pack and unpack a message in C++.
- *
- *      Foo foo = ...;
- *      Any any;
- *      any.PackFrom(foo);
- *      ...
- *      if (any.UnpackTo(&foo)) {
- *        ...
- *      }
- *
- *  Example 2: Pack and unpack a message in Java.
- *
- *      Foo foo = ...;
- *      Any any = Any.pack(foo);
- *      ...
- *      if (any.is(Foo.class)) {
- *        foo = any.unpack(Foo.class);
- *      }
- *      // or ...
- *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *        foo = any.unpack(Foo.getDefaultInstance());
- *      }
- *
- *   Example 3: Pack and unpack a message in Python.
- *
- *      foo = Foo(...)
- *      any = Any()
- *      any.Pack(foo)
- *      ...
- *      if any.Is(Foo.DESCRIPTOR):
- *        any.Unpack(foo)
- *        ...
- *
- *   Example 4: Pack and unpack a message in Go
- *
- *       foo := &pb.Foo{...}
- *       any, err := anypb.New(foo)
- *       if err != nil {
- *         ...
- *       }
- *       ...
- *       foo := &pb.Foo{}
- *       if err := any.UnmarshalTo(foo); err != nil {
- *         ...
- *       }
- *
- *  The pack methods provided by protobuf library will by default use
- *  'type.googleapis.com/full.type.name' as the type URL and the unpack
- *  methods only use the fully qualified type name after the last '/'
- *  in the type URL, for example "foo.bar.com/x/y.z" will yield type
- *  name "y.z".
- *
- *  JSON
- *  ====
- *  The JSON representation of an `Any` value uses the regular
- *  representation of the deserialized, embedded message, with an
- *  additional field `@type` which contains the type URL. Example:
- *
- *      package google.profile;
- *      message Person {
- *        string first_name = 1;
- *        string last_name = 2;
- *      }
- *
- *      {
- *        "@type": "type.googleapis.com/google.profile.Person",
- *        "firstName": <string>,
- *        "lastName": <string>
- *      }
- *
- *  If the embedded message type is well-known and has a custom JSON
- *  representation, that representation will be embedded adding a field
- *  `value` which holds the custom JSON in addition to the `@type`
- *  field. Example (for message [google.protobuf.Duration][]):
- *
- *      {
- *        "@type": "type.googleapis.com/google.protobuf.Duration",
- *        "value": "1.212s"
- *      }
- *
- */
-export interface TXAny {
-    /**
-     *  A URL/resource name that uniquely identifies the type of the serialized
-     *  protocol buffer message. This string must contain at least
-     *  one "/" character. The last segment of the URL's path must represent
-     *  the fully qualified name of the type (as in
-     *  `path/google.protobuf.Duration`). The name should be in a canonical form
-     *  (e.g., leading "." is not accepted).
-     *
-     *  In practice, teams usually precompile into the binary all types that they
-     *  expect it to use in the context of Any. However, for URLs which use the
-     *  scheme `http`, `https`, or no scheme, one can optionally set up a type
-     *  server that maps type URLs to message definitions as follows:
-     *
-     *  * If no scheme is provided, `https` is assumed.
-     *  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-     *    value in binary format, or produce an error.
-     *  * Applications are allowed to cache lookup results based on the
-     *    URL, or have them precompiled into a binary to avoid any
-     *    lookup. Therefore, binary compatibility needs to be preserved
-     *    on changes to types. (Use versioned type names to manage
-     *    breaking changes.)
-     *
-     *  Note: this functionality is not currently available in the official
-     *  protobuf release, and it is not used for type URLs beginning with
-     *  type.googleapis.com. As of May 2023, there are no widely used type server
-     *  implementations and no plans to implement one.
-     *
-     *  Schemes other than `http`, `https` (or the empty scheme) might be
-     *  used with implementation specific semantics.
-     *
-     */
-    type_url?: string;
-    /**
-     *  Must be a valid serialized protocol buffer of the above specified type.
-     */
-    value?: string;
-}
-/**
- * XAny
- *  `Any` contains an arbitrary serialized protocol buffer message along with a
- *  URL that describes the type of the serialized message.
- *
- *  Protobuf library provides support to pack/unpack Any values in the form
- *  of utility functions or additional generated methods of the Any type.
- *
- *  Example 1: Pack and unpack a message in C++.
- *
- *      Foo foo = ...;
- *      Any any;
- *      any.PackFrom(foo);
- *      ...
- *      if (any.UnpackTo(&foo)) {
- *        ...
- *      }
- *
- *  Example 2: Pack and unpack a message in Java.
- *
- *      Foo foo = ...;
- *      Any any = Any.pack(foo);
- *      ...
- *      if (any.is(Foo.class)) {
- *        foo = any.unpack(Foo.class);
- *      }
- *      // or ...
- *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *        foo = any.unpack(Foo.getDefaultInstance());
- *      }
- *
- *   Example 3: Pack and unpack a message in Python.
- *
- *      foo = Foo(...)
- *      any = Any()
- *      any.Pack(foo)
- *      ...
- *      if any.Is(Foo.DESCRIPTOR):
- *        any.Unpack(foo)
- *        ...
- *
- *   Example 4: Pack and unpack a message in Go
- *
- *       foo := &pb.Foo{...}
- *       any, err := anypb.New(foo)
- *       if err != nil {
- *         ...
- *       }
- *       ...
- *       foo := &pb.Foo{}
- *       if err := any.UnmarshalTo(foo); err != nil {
- *         ...
- *       }
- *
- *  The pack methods provided by protobuf library will by default use
- *  'type.googleapis.com/full.type.name' as the type URL and the unpack
- *  methods only use the fully qualified type name after the last '/'
- *  in the type URL, for example "foo.bar.com/x/y.z" will yield type
- *  name "y.z".
- *
- *  JSON
- *  ====
- *  The JSON representation of an `Any` value uses the regular
- *  representation of the deserialized, embedded message, with an
- *  additional field `@type` which contains the type URL. Example:
- *
- *      package google.profile;
- *      message Person {
- *        string first_name = 1;
- *        string last_name = 2;
- *      }
- *
- *      {
- *        "@type": "type.googleapis.com/google.profile.Person",
- *        "firstName": <string>,
- *        "lastName": <string>
- *      }
- *
- *  If the embedded message type is well-known and has a custom JSON
- *  representation, that representation will be embedded adding a field
- *  `value` which holds the custom JSON in addition to the `@type`
- *  field. Example (for message [google.protobuf.Duration][]):
- *
- *      {
- *        "@type": "type.googleapis.com/google.protobuf.Duration",
- *        "value": "1.212s"
- *      }
- *
- */
-export declare class XAny extends FieldNode {
-    private _typeUrl;
-    private _value;
-    __defaultValues: IXAny;
-    constructor(initData?: IXAny, parent?: FieldNode, parentAttributeName?: string);
-    get typeUrl(): STRING;
-    set typeUrl(v: string);
-    get value(): BYTES;
-    set value(v: string);
-    fromLiteral(data: IXAny): void;
-    toLiteral(): IXAny;
-}

package/dist/protoc-gen-open-models/google/protobuf/Any.js

@@ -1,213 +0,0 @@
-// Code generated by furo protoc-gen-open-models. DO NOT EDIT.
-// protoc-gen-open-models version: ????
-import { BYTES, FieldNode, Registry, STRING, } from '@furo/open-models/dist/index';
-/**
- * XAny
- *  `Any` contains an arbitrary serialized protocol buffer message along with a
- *  URL that describes the type of the serialized message.
- *
- *  Protobuf library provides support to pack/unpack Any values in the form
- *  of utility functions or additional generated methods of the Any type.
- *
- *  Example 1: Pack and unpack a message in C++.
- *
- *      Foo foo = ...;
- *      Any any;
- *      any.PackFrom(foo);
- *      ...
- *      if (any.UnpackTo(&foo)) {
- *        ...
- *      }
- *
- *  Example 2: Pack and unpack a message in Java.
- *
- *      Foo foo = ...;
- *      Any any = Any.pack(foo);
- *      ...
- *      if (any.is(Foo.class)) {
- *        foo = any.unpack(Foo.class);
- *      }
- *      // or ...
- *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *        foo = any.unpack(Foo.getDefaultInstance());
- *      }
- *
- *   Example 3: Pack and unpack a message in Python.
- *
- *      foo = Foo(...)
- *      any = Any()
- *      any.Pack(foo)
- *      ...
- *      if any.Is(Foo.DESCRIPTOR):
- *        any.Unpack(foo)
- *        ...
- *
- *   Example 4: Pack and unpack a message in Go
- *
- *       foo := &pb.Foo{...}
- *       any, err := anypb.New(foo)
- *       if err != nil {
- *         ...
- *       }
- *       ...
- *       foo := &pb.Foo{}
- *       if err := any.UnmarshalTo(foo); err != nil {
- *         ...
- *       }
- *
- *  The pack methods provided by protobuf library will by default use
- *  'type.googleapis.com/full.type.name' as the type URL and the unpack
- *  methods only use the fully qualified type name after the last '/'
- *  in the type URL, for example "foo.bar.com/x/y.z" will yield type
- *  name "y.z".
- *
- *  JSON
- *  ====
- *  The JSON representation of an `Any` value uses the regular
- *  representation of the deserialized, embedded message, with an
- *  additional field `@type` which contains the type URL. Example:
- *
- *      package google.profile;
- *      message Person {
- *        string first_name = 1;
- *        string last_name = 2;
- *      }
- *
- *      {
- *        "@type": "type.googleapis.com/google.profile.Person",
- *        "firstName": <string>,
- *        "lastName": <string>
- *      }
- *
- *  If the embedded message type is well-known and has a custom JSON
- *  representation, that representation will be embedded adding a field
- *  `value` which holds the custom JSON in addition to the `@type`
- *  field. Example (for message [google.protobuf.Duration][]):
- *
- *      {
- *        "@type": "type.googleapis.com/google.protobuf.Duration",
- *        "value": "1.212s"
- *      }
- *
- */
-export class XAny extends FieldNode {
-    constructor(initData, parent, parentAttributeName) {
-        super(undefined, parent, parentAttributeName);
-        this.__meta.typeName = 'google.protobuf.Any';
-        this.__meta.nodeFields = [
-            {
-                fieldName: 'typeUrl',
-                protoName: 'type_url',
-                FieldConstructor: STRING,
-                constraints: {},
-            },
-            {
-                fieldName: 'value',
-                protoName: 'value',
-                FieldConstructor: BYTES,
-                constraints: {},
-            },
-        ];
-        // Initialize the fields
-        //  A URL/resource name that uniquely identifies the type of the serialized
-        //  protocol buffer message. This string must contain at least
-        //  one "/" character. The last segment of the URL's path must represent
-        //  the fully qualified name of the type (as in
-        //  `path/google.protobuf.Duration`). The name should be in a canonical form
-        //  (e.g., leading "." is not accepted).
-        //
-        //  In practice, teams usually precompile into the binary all types that they
-        //  expect it to use in the context of Any. However, for URLs which use the
-        //  scheme `http`, `https`, or no scheme, one can optionally set up a type
-        //  server that maps type URLs to message definitions as follows:
-        //
-        //  * If no scheme is provided, `https` is assumed.
-        //  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-        //    value in binary format, or produce an error.
-        //  * Applications are allowed to cache lookup results based on the
-        //    URL, or have them precompiled into a binary to avoid any
-        //    lookup. Therefore, binary compatibility needs to be preserved
-        //    on changes to types. (Use versioned type names to manage
-        //    breaking changes.)
-        //
-        //  Note: this functionality is not currently available in the official
-        //  protobuf release, and it is not used for type URLs beginning with
-        //  type.googleapis.com. As of May 2023, there are no widely used type server
-        //  implementations and no plans to implement one.
-        //
-        //  Schemes other than `http`, `https` (or the empty scheme) might be
-        //  used with implementation specific semantics.
-        //
-        this._typeUrl = new STRING(undefined, this, 'typeUrl');
-        //  Must be a valid serialized protocol buffer of the above specified type.
-        this._value = new BYTES(undefined, this, 'value');
-        // Set required fields
-        [].forEach(fieldName => {
-            this[fieldName].__meta.required = true;
-        });
-        // Default values from openAPI annotations
-        this.__defaultValues = {};
-        // Initialize the fields with init data
-        if (initData !== undefined) {
-            this.__fromLiteral({ ...this.__defaultValues, ...initData });
-        }
-        else {
-            this.__fromLiteral(this.__defaultValues);
-        }
-        // Set readonly fields after the init, so child nodes are readonly too
-        [].forEach(fieldName => {
-            this[fieldName].__readonly = true;
-        });
-        this.__meta.isPristine = true;
-    }
-    //  A URL/resource name that uniquely identifies the type of the serialized
-    //  protocol buffer message. This string must contain at least
-    //  one "/" character. The last segment of the URL's path must represent
-    //  the fully qualified name of the type (as in
-    //  `path/google.protobuf.Duration`). The name should be in a canonical form
-    //  (e.g., leading "." is not accepted).
-    //
-    //  In practice, teams usually precompile into the binary all types that they
-    //  expect it to use in the context of Any. However, for URLs which use the
-    //  scheme `http`, `https`, or no scheme, one can optionally set up a type
-    //  server that maps type URLs to message definitions as follows:
-    //
-    //  * If no scheme is provided, `https` is assumed.
-    //  * An HTTP GET on the URL must yield a [google.protobuf.Type][]
-    //    value in binary format, or produce an error.
-    //  * Applications are allowed to cache lookup results based on the
-    //    URL, or have them precompiled into a binary to avoid any
-    //    lookup. Therefore, binary compatibility needs to be preserved
-    //    on changes to types. (Use versioned type names to manage
-    //    breaking changes.)
-    //
-    //  Note: this functionality is not currently available in the official
-    //  protobuf release, and it is not used for type URLs beginning with
-    //  type.googleapis.com. As of May 2023, there are no widely used type server
-    //  implementations and no plans to implement one.
-    //
-    //  Schemes other than `http`, `https` (or the empty scheme) might be
-    //  used with implementation specific semantics.
-    //
-    get typeUrl() {
-        return this._typeUrl;
-    }
-    set typeUrl(v) {
-        this.__PrimitivesSetter(this._typeUrl, v);
-    }
-    //  Must be a valid serialized protocol buffer of the above specified type.
-    get value() {
-        return this._value;
-    }
-    set value(v) {
-        this.__PrimitivesSetter(this._value, v);
-    }
-    fromLiteral(data) {
-        super.__fromLiteral(data);
-    }
-    toLiteral() {
-        return super.__toLiteral();
-    }
-}
-Registry.register('google.protobuf.Any', XAny);
-//# sourceMappingURL=Any.js.map

package/dist/protoc-gen-open-models/google/protobuf/Any.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Any.js","sourceRoot":"","sources":["../../../../protoc-gen-open-models/google/protobuf/Any.ts"],"names":[],"mappings":"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","sourcesContent":["// Code generated by furo protoc-gen-open-models. DO NOT EDIT.\n// protoc-gen-open-models version: ????\n\nimport {\n  BYTES,\n  FieldNode,\n  Registry,\n  STRING,\n} from '@furo/open-models/dist/index';\n\n/**\n * @interface IXAny\n *  `Any` contains an arbitrary serialized protocol buffer message along with a\n *  URL that describes the type of the serialized message.\n *\n *  Protobuf library provides support to pack/unpack Any values in the form\n *  of utility functions or additional generated methods of the Any type.\n *\n *  Example 1: Pack and unpack a message in C++.\n *\n *      Foo foo = ...;\n *      Any any;\n *      any.PackFrom(foo);\n *      ...\n *      if (any.UnpackTo(&foo)) {\n *        ...\n *      }\n *\n *  Example 2: Pack and unpack a message in Java.\n *\n *      Foo foo = ...;\n *      Any any = Any.pack(foo);\n *      ...\n *      if (any.is(Foo.class)) {\n *        foo = any.unpack(Foo.class);\n *      }\n *      // or ...\n *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n *        foo = any.unpack(Foo.getDefaultInstance());\n *      }\n *\n *   Example 3: Pack and unpack a message in Python.\n *\n *      foo = Foo(...)\n *      any = Any()\n *      any.Pack(foo)\n *      ...\n *      if any.Is(Foo.DESCRIPTOR):\n *        any.Unpack(foo)\n *        ...\n *\n *   Example 4: Pack and unpack a message in Go\n *\n *       foo := &pb.Foo{...}\n *       any, err := anypb.New(foo)\n *       if err != nil {\n *         ...\n *       }\n *       ...\n *       foo := &pb.Foo{}\n *       if err := any.UnmarshalTo(foo); err != nil {\n *         ...\n *       }\n *\n *  The pack methods provided by protobuf library will by default use\n *  'type.googleapis.com/full.type.name' as the type URL and the unpack\n *  methods only use the fully qualified type name after the last '/'\n *  in the type URL, for example \"foo.bar.com/x/y.z\" will yield type\n *  name \"y.z\".\n *\n *  JSON\n *  ====\n *  The JSON representation of an `Any` value uses the regular\n *  representation of the deserialized, embedded message, with an\n *  additional field `@type` which contains the type URL. Example:\n *\n *      package google.profile;\n *      message Person {\n *        string first_name = 1;\n *        string last_name = 2;\n *      }\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.profile.Person\",\n *        \"firstName\": <string>,\n *        \"lastName\": <string>\n *      }\n *\n *  If the embedded message type is well-known and has a custom JSON\n *  representation, that representation will be embedded adding a field\n *  `value` which holds the custom JSON in addition to the `@type`\n *  field. Example (for message [google.protobuf.Duration][]):\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n *        \"value\": \"1.212s\"\n *      }\n *\n */\nexport interface IXAny {\n  /**\n   *  A URL/resource name that uniquely identifies the type of the serialized\n   *  protocol buffer message. This string must contain at least\n   *  one \"/\" character. The last segment of the URL's path must represent\n   *  the fully qualified name of the type (as in\n   *  `path/google.protobuf.Duration`). The name should be in a canonical form\n   *  (e.g., leading \".\" is not accepted).\n   *\n   *  In practice, teams usually precompile into the binary all types that they\n   *  expect it to use in the context of Any. However, for URLs which use the\n   *  scheme `http`, `https`, or no scheme, one can optionally set up a type\n   *  server that maps type URLs to message definitions as follows:\n   *\n   *  * If no scheme is provided, `https` is assumed.\n   *  * An HTTP GET on the URL must yield a [google.protobuf.Type][]\n   *    value in binary format, or produce an error.\n   *  * Applications are allowed to cache lookup results based on the\n   *    URL, or have them precompiled into a binary to avoid any\n   *    lookup. Therefore, binary compatibility needs to be preserved\n   *    on changes to types. (Use versioned type names to manage\n   *    breaking changes.)\n   *\n   *  Note: this functionality is not currently available in the official\n   *  protobuf release, and it is not used for type URLs beginning with\n   *  type.googleapis.com. As of May 2023, there are no widely used type server\n   *  implementations and no plans to implement one.\n   *\n   *  Schemes other than `http`, `https` (or the empty scheme) might be\n   *  used with implementation specific semantics.\n   *\n   */\n  typeUrl?: string;\n  /**\n   *  Must be a valid serialized protocol buffer of the above specified type.\n   */\n  value?: string;\n}\n\n/**\n * @interface TXAny\n *  `Any` contains an arbitrary serialized protocol buffer message along with a\n *  URL that describes the type of the serialized message.\n *\n *  Protobuf library provides support to pack/unpack Any values in the form\n *  of utility functions or additional generated methods of the Any type.\n *\n *  Example 1: Pack and unpack a message in C++.\n *\n *      Foo foo = ...;\n *      Any any;\n *      any.PackFrom(foo);\n *      ...\n *      if (any.UnpackTo(&foo)) {\n *        ...\n *      }\n *\n *  Example 2: Pack and unpack a message in Java.\n *\n *      Foo foo = ...;\n *      Any any = Any.pack(foo);\n *      ...\n *      if (any.is(Foo.class)) {\n *        foo = any.unpack(Foo.class);\n *      }\n *      // or ...\n *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n *        foo = any.unpack(Foo.getDefaultInstance());\n *      }\n *\n *   Example 3: Pack and unpack a message in Python.\n *\n *      foo = Foo(...)\n *      any = Any()\n *      any.Pack(foo)\n *      ...\n *      if any.Is(Foo.DESCRIPTOR):\n *        any.Unpack(foo)\n *        ...\n *\n *   Example 4: Pack and unpack a message in Go\n *\n *       foo := &pb.Foo{...}\n *       any, err := anypb.New(foo)\n *       if err != nil {\n *         ...\n *       }\n *       ...\n *       foo := &pb.Foo{}\n *       if err := any.UnmarshalTo(foo); err != nil {\n *         ...\n *       }\n *\n *  The pack methods provided by protobuf library will by default use\n *  'type.googleapis.com/full.type.name' as the type URL and the unpack\n *  methods only use the fully qualified type name after the last '/'\n *  in the type URL, for example \"foo.bar.com/x/y.z\" will yield type\n *  name \"y.z\".\n *\n *  JSON\n *  ====\n *  The JSON representation of an `Any` value uses the regular\n *  representation of the deserialized, embedded message, with an\n *  additional field `@type` which contains the type URL. Example:\n *\n *      package google.profile;\n *      message Person {\n *        string first_name = 1;\n *        string last_name = 2;\n *      }\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.profile.Person\",\n *        \"firstName\": <string>,\n *        \"lastName\": <string>\n *      }\n *\n *  If the embedded message type is well-known and has a custom JSON\n *  representation, that representation will be embedded adding a field\n *  `value` which holds the custom JSON in addition to the `@type`\n *  field. Example (for message [google.protobuf.Duration][]):\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n *        \"value\": \"1.212s\"\n *      }\n *\n */\nexport interface TXAny {\n  /**\n   *  A URL/resource name that uniquely identifies the type of the serialized\n   *  protocol buffer message. This string must contain at least\n   *  one \"/\" character. The last segment of the URL's path must represent\n   *  the fully qualified name of the type (as in\n   *  `path/google.protobuf.Duration`). The name should be in a canonical form\n   *  (e.g., leading \".\" is not accepted).\n   *\n   *  In practice, teams usually precompile into the binary all types that they\n   *  expect it to use in the context of Any. However, for URLs which use the\n   *  scheme `http`, `https`, or no scheme, one can optionally set up a type\n   *  server that maps type URLs to message definitions as follows:\n   *\n   *  * If no scheme is provided, `https` is assumed.\n   *  * An HTTP GET on the URL must yield a [google.protobuf.Type][]\n   *    value in binary format, or produce an error.\n   *  * Applications are allowed to cache lookup results based on the\n   *    URL, or have them precompiled into a binary to avoid any\n   *    lookup. Therefore, binary compatibility needs to be preserved\n   *    on changes to types. (Use versioned type names to manage\n   *    breaking changes.)\n   *\n   *  Note: this functionality is not currently available in the official\n   *  protobuf release, and it is not used for type URLs beginning with\n   *  type.googleapis.com. As of May 2023, there are no widely used type server\n   *  implementations and no plans to implement one.\n   *\n   *  Schemes other than `http`, `https` (or the empty scheme) might be\n   *  used with implementation specific semantics.\n   *\n   */\n  type_url?: string;\n  /**\n   *  Must be a valid serialized protocol buffer of the above specified type.\n   */\n  value?: string;\n}\n\n/**\n * XAny\n *  `Any` contains an arbitrary serialized protocol buffer message along with a\n *  URL that describes the type of the serialized message.\n *\n *  Protobuf library provides support to pack/unpack Any values in the form\n *  of utility functions or additional generated methods of the Any type.\n *\n *  Example 1: Pack and unpack a message in C++.\n *\n *      Foo foo = ...;\n *      Any any;\n *      any.PackFrom(foo);\n *      ...\n *      if (any.UnpackTo(&foo)) {\n *        ...\n *      }\n *\n *  Example 2: Pack and unpack a message in Java.\n *\n *      Foo foo = ...;\n *      Any any = Any.pack(foo);\n *      ...\n *      if (any.is(Foo.class)) {\n *        foo = any.unpack(Foo.class);\n *      }\n *      // or ...\n *      if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n *        foo = any.unpack(Foo.getDefaultInstance());\n *      }\n *\n *   Example 3: Pack and unpack a message in Python.\n *\n *      foo = Foo(...)\n *      any = Any()\n *      any.Pack(foo)\n *      ...\n *      if any.Is(Foo.DESCRIPTOR):\n *        any.Unpack(foo)\n *        ...\n *\n *   Example 4: Pack and unpack a message in Go\n *\n *       foo := &pb.Foo{...}\n *       any, err := anypb.New(foo)\n *       if err != nil {\n *         ...\n *       }\n *       ...\n *       foo := &pb.Foo{}\n *       if err := any.UnmarshalTo(foo); err != nil {\n *         ...\n *       }\n *\n *  The pack methods provided by protobuf library will by default use\n *  'type.googleapis.com/full.type.name' as the type URL and the unpack\n *  methods only use the fully qualified type name after the last '/'\n *  in the type URL, for example \"foo.bar.com/x/y.z\" will yield type\n *  name \"y.z\".\n *\n *  JSON\n *  ====\n *  The JSON representation of an `Any` value uses the regular\n *  representation of the deserialized, embedded message, with an\n *  additional field `@type` which contains the type URL. Example:\n *\n *      package google.profile;\n *      message Person {\n *        string first_name = 1;\n *        string last_name = 2;\n *      }\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.profile.Person\",\n *        \"firstName\": <string>,\n *        \"lastName\": <string>\n *      }\n *\n *  If the embedded message type is well-known and has a custom JSON\n *  representation, that representation will be embedded adding a field\n *  `value` which holds the custom JSON in addition to the `@type`\n *  field. Example (for message [google.protobuf.Duration][]):\n *\n *      {\n *        \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n *        \"value\": \"1.212s\"\n *      }\n *\n */\nexport class XAny extends FieldNode {\n  //  A URL/resource name that uniquely identifies the type of the serialized\n  //  protocol buffer message. This string must contain at least\n  //  one \"/\" character. The last segment of the URL's path must represent\n  //  the fully qualified name of the type (as in\n  //  `path/google.protobuf.Duration`). The name should be in a canonical form\n  //  (e.g., leading \".\" is not accepted).\n  //\n  //  In practice, teams usually precompile into the binary all types that they\n  //  expect it to use in the context of Any. However, for URLs which use the\n  //  scheme `http`, `https`, or no scheme, one can optionally set up a type\n  //  server that maps type URLs to message definitions as follows:\n  //\n  //  * If no scheme is provided, `https` is assumed.\n  //  * An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  //    value in binary format, or produce an error.\n  //  * Applications are allowed to cache lookup results based on the\n  //    URL, or have them precompiled into a binary to avoid any\n  //    lookup. Therefore, binary compatibility needs to be preserved\n  //    on changes to types. (Use versioned type names to manage\n  //    breaking changes.)\n  //\n  //  Note: this functionality is not currently available in the official\n  //  protobuf release, and it is not used for type URLs beginning with\n  //  type.googleapis.com. As of May 2023, there are no widely used type server\n  //  implementations and no plans to implement one.\n  //\n  //  Schemes other than `http`, `https` (or the empty scheme) might be\n  //  used with implementation specific semantics.\n  //\n  private _typeUrl: STRING;\n\n  //  Must be a valid serialized protocol buffer of the above specified type.\n  private _value: BYTES;\n\n  public __defaultValues: IXAny;\n\n  constructor(\n    initData?: IXAny,\n    parent?: FieldNode,\n    parentAttributeName?: string,\n  ) {\n    super(undefined, parent, parentAttributeName);\n    this.__meta.typeName = 'google.protobuf.Any';\n\n    this.__meta.nodeFields = [\n      {\n        fieldName: 'typeUrl',\n        protoName: 'type_url',\n        FieldConstructor: STRING,\n        constraints: {},\n      },\n      {\n        fieldName: 'value',\n        protoName: 'value',\n        FieldConstructor: BYTES,\n        constraints: {},\n      },\n    ];\n\n    // Initialize the fields\n    //  A URL/resource name that uniquely identifies the type of the serialized\n    //  protocol buffer message. This string must contain at least\n    //  one \"/\" character. The last segment of the URL's path must represent\n    //  the fully qualified name of the type (as in\n    //  `path/google.protobuf.Duration`). The name should be in a canonical form\n    //  (e.g., leading \".\" is not accepted).\n    //\n    //  In practice, teams usually precompile into the binary all types that they\n    //  expect it to use in the context of Any. However, for URLs which use the\n    //  scheme `http`, `https`, or no scheme, one can optionally set up a type\n    //  server that maps type URLs to message definitions as follows:\n    //\n    //  * If no scheme is provided, `https` is assumed.\n    //  * An HTTP GET on the URL must yield a [google.protobuf.Type][]\n    //    value in binary format, or produce an error.\n    //  * Applications are allowed to cache lookup results based on the\n    //    URL, or have them precompiled into a binary to avoid any\n    //    lookup. Therefore, binary compatibility needs to be preserved\n    //    on changes to types. (Use versioned type names to manage\n    //    breaking changes.)\n    //\n    //  Note: this functionality is not currently available in the official\n    //  protobuf release, and it is not used for type URLs beginning with\n    //  type.googleapis.com. As of May 2023, there are no widely used type server\n    //  implementations and no plans to implement one.\n    //\n    //  Schemes other than `http`, `https` (or the empty scheme) might be\n    //  used with implementation specific semantics.\n    //\n    this._typeUrl = new STRING(undefined, this, 'typeUrl');\n\n    //  Must be a valid serialized protocol buffer of the above specified type.\n    this._value = new BYTES(undefined, this, 'value');\n\n    // Set required fields\n    [].forEach(fieldName => {\n      (this[fieldName as keyof XAny] as FieldNode).__meta.required = true;\n    });\n\n    // Default values from openAPI annotations\n    this.__defaultValues = {};\n\n    // Initialize the fields with init data\n    if (initData !== undefined) {\n      this.__fromLiteral({ ...this.__defaultValues, ...initData });\n    } else {\n      this.__fromLiteral(this.__defaultValues);\n    }\n\n    // Set readonly fields after the init, so child nodes are readonly too\n    [].forEach(fieldName => {\n      (this[fieldName as keyof XAny] as FieldNode).__readonly = true;\n    });\n\n    this.__meta.isPristine = true;\n  }\n\n  //  A URL/resource name that uniquely identifies the type of the serialized\n  //  protocol buffer message. This string must contain at least\n  //  one \"/\" character. The last segment of the URL's path must represent\n  //  the fully qualified name of the type (as in\n  //  `path/google.protobuf.Duration`). The name should be in a canonical form\n  //  (e.g., leading \".\" is not accepted).\n  //\n  //  In practice, teams usually precompile into the binary all types that they\n  //  expect it to use in the context of Any. However, for URLs which use the\n  //  scheme `http`, `https`, or no scheme, one can optionally set up a type\n  //  server that maps type URLs to message definitions as follows:\n  //\n  //  * If no scheme is provided, `https` is assumed.\n  //  * An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  //    value in binary format, or produce an error.\n  //  * Applications are allowed to cache lookup results based on the\n  //    URL, or have them precompiled into a binary to avoid any\n  //    lookup. Therefore, binary compatibility needs to be preserved\n  //    on changes to types. (Use versioned type names to manage\n  //    breaking changes.)\n  //\n  //  Note: this functionality is not currently available in the official\n  //  protobuf release, and it is not used for type URLs beginning with\n  //  type.googleapis.com. As of May 2023, there are no widely used type server\n  //  implementations and no plans to implement one.\n  //\n  //  Schemes other than `http`, `https` (or the empty scheme) might be\n  //  used with implementation specific semantics.\n  //\n  public get typeUrl(): STRING {\n    return this._typeUrl;\n  }\n\n  public set typeUrl(v: string) {\n    this.__PrimitivesSetter(this._typeUrl, v);\n  }\n\n  //  Must be a valid serialized protocol buffer of the above specified type.\n  public get value(): BYTES {\n    return this._value;\n  }\n\n  public set value(v: string) {\n    this.__PrimitivesSetter(this._value, v);\n  }\n\n  fromLiteral(data: IXAny) {\n    super.__fromLiteral(data);\n  }\n\n  toLiteral(): IXAny {\n    return super.__toLiteral();\n  }\n}\n\nRegistry.register('google.protobuf.Any', XAny);\n"]}

package/dist/protoc-gen-open-models/google/protobuf/BoolValue.d.ts

@@ -1,40 +0,0 @@
-import { BOOLEAN, FieldNode } from '@furo/open-models/dist/index';
-/**
- * @interface IBoolValue
- *  Wrapper message for `bool`.
- *
- *  The JSON representation for `BoolValue` is JSON `true` and `false`.
- */
-export interface IBoolValue {
-    /**
-     *  The bool value.
-     */
-    value?: boolean;
-}
-/**
- * @interface TBoolValue
- *  Wrapper message for `bool`.
- *
- *  The JSON representation for `BoolValue` is JSON `true` and `false`.
- */
-export interface TBoolValue {
-    /**
-     *  The bool value.
-     */
-    value?: boolean;
-}
-/**
- * BoolValue
- *  Wrapper message for `bool`.
- *
- *  The JSON representation for `BoolValue` is JSON `true` and `false`.
- */
-export declare class BoolValue extends FieldNode {
-    private _value;
-    __defaultValues: IBoolValue;
-    constructor(initData?: IBoolValue, parent?: FieldNode, parentAttributeName?: string);
-    get value(): BOOLEAN;
-    set value(v: boolean);
-    fromLiteral(data: IBoolValue): void;
-    toLiteral(): IBoolValue;
-}