declare namespace $wrapper {
    export namespace wix {
        export namespace common {
            /**
             * Physical address
             */
            export interface Address {
                /**
                 * Country code.
                 */
                country?: (string | null);
                /**
                 * Subdivision shorthand. Usually, a short code (2 or 3 letters) that represents a state, region, prefecture, or province. e.g. NY
                 */
                subdivision?: (string | null);
                /**
                 * Subdivision. Usually a state, region, prefecture, or province code, according to [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2), e.g. US-NY
                 */
                subdivisionIso31662?: (string | null);
                /**
                 * City name.
                 */
                city?: (string | null);
                /**
                 * Zip/postal code.
                 */
                postalCode?: (string | null);
                /**
                 * Street name and number.
                 */
                streetAddress?: ($wrapper.wix.common.StreetAddress | null);
                /**
                 * Main address line, usually street and number as free text.
                 */
                addressLine?: (string | null);
                /**
                 * Free text providing more detailed address info. Usually contains Apt, Suite, and Floor.
                 */
                addressLine2?: (string | null);
                /**
                 * A string containing the full address of this location.
                 */
                formattedAddress?: (string | null);
                /**
                 * Free text to help find the address.
                 */
                hint?: (string | null);
                /**
                 * Coordinates of the physical address.
                 */
                geocode?: ($wrapper.wix.common.AddressLocation | null);
                /**
                 * Country full name.
                 */
                countryFullname?: (string | null);
                /**
                 * Subdivision full name.
                 */
                subdivisionFullname?: (string | null);
                /**
                 * Multi-level subdivisions from top to bottom.
                 */
                subdivisions?: ($wrapper.wix.common.Subdivision[] | null);
            }
            export interface Subdivision {
                /**
                 * Short subdivision code.
                 */
                code?: (string | null);
                /**
                 * Subdivision full name.
                 */
                name?: (string | null);
                /**
                 * Subdivision level
                 */
                type?: ($wrapper.wix.common.Subdivision.SubdivisionType | null);
                /**
                 * Free text description of subdivision type.
                 */
                typeInfo?: (string | null);
                /**
                 * Standard organizations details (e.g. ISO).
                 */
                standardDetails?: ($wrapper.wix.common.Subdivision.StandardDetails | null);
            }
            export namespace Subdivision {
                export enum SubdivisionType {
                    UNKNOWN_SUBDIVISION_TYPE = "UNKNOWN_SUBDIVISION_TYPE",
                    ADMINISTRATIVE_AREA_LEVEL_1 = "ADMINISTRATIVE_AREA_LEVEL_1",
                    ADMINISTRATIVE_AREA_LEVEL_2 = "ADMINISTRATIVE_AREA_LEVEL_2",
                    ADMINISTRATIVE_AREA_LEVEL_3 = "ADMINISTRATIVE_AREA_LEVEL_3",
                    ADMINISTRATIVE_AREA_LEVEL_4 = "ADMINISTRATIVE_AREA_LEVEL_4",
                    ADMINISTRATIVE_AREA_LEVEL_5 = "ADMINISTRATIVE_AREA_LEVEL_5",
                    COUNTRY = "COUNTRY",
                }
                /**
                 * Subdivision Concordance values
                 */
                export interface StandardDetails {
                    /**
                     * subdivision iso-3166-2 code according to [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2). e.g. US-NY, GB-SCT, NO-30
                     */
                    iso31662?: (string | null);
                }
            }
            export interface StreetAddress {
                /**
                 * Street number.
                 */
                number?: (string | null);
                /**
                 * Street name.
                 */
                name?: (string | null);
                /**
                 * Apartment number.
                 */
                apt?: (string | null);
                /**
                 * Optional address line 1
                 */
                formattedAddressLine?: (string | null);
            }
            /**
             * Contact details for the address
             */
            export interface AddressContactDetails {
                /**
                 * Contact's full name.
                 */
                fullName?: (string | null);
                /**
                 * Contact's phone number.
                 */
                phone?: (string | null);
                /**
                 * Contact's company name.
                 */
                company?: (string | null);
                /**
                 * Email associated with the address.
                 */
                email?: (string | null);
            }
            /**
             * Full contact details for an address
             */
            export interface FullAddressContactDetails {
                /**
                 * Contact's first name.
                 */
                firstName?: (string | null);
                /**
                 * Contact's last name.
                 */
                lastName?: (string | null);
                /**
                 * Contact's full name.
                 */
                fullName?: (string | null);
                /**
                 * Contact's phone number.
                 */
                phone?: (string | null);
                /**
                 * Contact's company name.
                 */
                company?: (string | null);
                /**
                 * Email associated with the address.
                 */
                email?: (string | null);
                /**
                 * Tax info. Currently usable only in Brazil.
                 */
                vatId?: ($wrapper.wix.common.VatId | null);
            }
            export interface VatId {
                /**
                 * Customer's tax ID.
                 */
                id?: (string | null);
                /**
                 * Tax type.
                 * 
                 * Supported values:
                 * + `CPF`: for individual tax payers
                 * + `CNPJ`: for corporations
                 */
                type?: ($wrapper.wix.common.VatType | null);
            }
            /**
             * tax info types
             */
            export enum VatType {
                UNSPECIFIED = "UNSPECIFIED",
                CPF = "CPF",
                CNPJ = "CNPJ",
            }
            export interface AddressLocation {
                /**
                 * Address latitude.
                 */
                latitude?: (number | null);
                /**
                 * Address longitude.
                 */
                longitude?: (number | null);
            }
            export interface BulkActionMetadata {
                /**
                 * Number of items that were successfully processed.
                 */
                totalSuccesses?: (number | null);
                /**
                 * Number of items that couldn't be processed.
                 */
                totalFailures?: (number | null);
                /**
                 * Number of failures without details because detailed failure threshold was exceeded.
                 */
                undetailedFailures?: (number | null);
            }
            export interface ItemMetadata {
                /**
                 * Item ID. Should always be available, unless it's impossible (for example, when failing to create an item).
                 */
                id?: (string | null);
                /**
                 * Index of the item within the request array. Allows for correlation between request and response items.
                 */
                originalIndex?: (number | null);
                /**
                 * Whether the requested action was successful for this item. When `false`, the `error` field is populated.
                 */
                success?: (boolean | null);
                /**
                 * Details about the error in case of failure.
                 */
                error?: ($wrapper.wix.api.ApplicationError | null);
            }
            export enum BulkActionType {
                UNKNOWN_ACTION_TYPE = "UNKNOWN_ACTION_TYPE",
                INSERT = "INSERT",
                UPDATE = "UPDATE",
                DELETE = "DELETE",
            }
            export interface IdentificationData {
                /**
                 * ID of of a contact in the site's [CRM by Ascend](https://www.wix.com/ascend/crm) system.
                 */
                contactId?: (string | null);
                identityType?: ($wrapper.wix.common.IdentificationData.IdentityType | null);
                /**
                 * ID of a site visitor that has not logged in to the site.
                 */
                anonymousVisitorId?: (string | null);
                /**
                 * ID of a site visitor that has logged in to the site.
                 */
                memberId?: (string | null);
                /**
                 * ID of a Wix user (site owner, contributor, etc.).
                 */
                wixUserId?: (string | null);
                /**
                 * ID of an app.
                 */
                appId?: (string | null);
            }
            export namespace IdentificationData {
                export enum IdentityType {
                    UNKNOWN = "UNKNOWN",
                    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
                    MEMBER = "MEMBER",
                    WIX_USER = "WIX_USER",
                    APP = "APP",
                }
            }
            /**
             * flynt-disable deleted-field-enum-reserved
             */
            export interface Image {
                /**
                 * WixMedia image ID.
                 */
                id?: (string | null);
                /**
                 * Image URL.
                 */
                url?: (string | null);
                /**
                 * Original image height.
                 */
                height?: (number | null);
                /**
                 * Original image width.
                 */
                width?: (number | null);
                /**
                 * Image alt text.
                 */
                altText?: (string | null);
                /**
                 * Image URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Image filename.
                 */
                filename?: (string | null);
                /**
                 * Image size in bytes.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Focal point of the image.
                 */
                focalPoint?: ($wrapper.wix.common.FocalPoint | null);
            }
            /**
             * Deprecated - use VideoV2
             */
            export interface Video {
                /**
                 * WixMedia ID
                 */
                id?: (string | null);
                /**
                 * URL of video
                 */
                url?: (string | null);
                /**
                 * Original image height
                 */
                height?: (number | null);
                /**
                 * Original image width
                 */
                width?: (number | null);
                /**
                 * Video poster
                 */
                thumbnail?: ($wrapper.wix.common.Image | null);
            }
            export interface VideoV2 {
                /**
                 * WixMedia ID.
                 */
                id?: (string | null);
                /**
                 * Original video URL.
                 */
                url?: (string | null);
                /**
                 * Available resolutions for the video, starting with the optimal resolution.
                 */
                resolutions?: ($wrapper.wix.common.VideoResolution[] | null);
                /**
                 * Video filename.
                 */
                filename?: (string | null);
                /**
                 * Video posters.
                 */
                posters?: ($wrapper.wix.common.Image[] | null);
                /**
                 * Original video size in bytes.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Video URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Original video duration in milliseconds.
                 */
                durationInMilliseconds?: (number | null);
                /**
                 * A short title for the video. will be used for SEO purposes.
                 */
                title?: (string | null);
                /**
                 * A long description for the video. will be used for SEO purposes.
                 */
                description?: (string | null);
                /**
                 * Original video height.
                 */
                height?: (number | null);
                /**
                 * Original video width.
                 */
                width?: (number | null);
            }
            export interface VideoResolution {
                /**
                 * Video URL.
                 */
                url?: (string | null);
                /**
                 * Video height.
                 */
                height?: (number | null);
                /**
                 * Video width.
                 */
                width?: (number | null);
                /**
                 * Deprecated. Use the `posters` property in the parent entity instead.
                 */
                poster?: ($wrapper.wix.common.Image | null);
                /**
                 * Video format for example, mp4, hls.
                 */
                format?: (string | null);
                /**
                 * Deprecated. Use the `urlExpirationDate` property in the parent entity instead.
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Deprecated. Use the `sizeInBytes` property in the parent entity instead. Size cannot be provided per resolution.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Video quality. For example: 480p, 720p.
                 */
                quality?: (string | null);
                /**
                 * Video filename.
                 */
                filename?: (string | null);
                /**
                 * Video duration in seconds.
                 */
                durationInSeconds?: (number | null);
                /**
                 * Video duration in milliseconds.
                 */
                durationInMilliseconds?: (number | null);
                /**
                 * When true, this is a protected asset, and calling the URL will return a 403 error.
                 * In order to access private assets, make a request to:
                 * `GenerateFileDownloadUrl` with the WixMedia id and specify the asset_key in the request
                 */
                private?: (boolean | null);
                /**
                 * Key to identify the video resolution's relationship to the original media in WixMedia.
                 * Can be used to request a download for the specific video resolution.
                 * For example: 480p.mp4, 720p.mp4, 1080p.mp4, trailer-720p.mp4, clip-720p.mp4
                 */
                assetKey?: (string | null);
            }
            export interface Audio {
                /**
                 * WixMedia ID.
                 */
                id?: (string | null);
                /**
                 * Audio URL.
                 */
                url?: (string | null);
                /**
                 * Audio URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Audio size in bytes.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Audio filename.
                 */
                filename?: (string | null);
                /**
                 * Audio duration in milliseconds.
                 */
                duration?: (number | null);
                /**
                 * When true, this is a protected asset, and calling the URL will return a 403 error.
                 * In order to access private assets, make a request to:
                 * `GenerateFileDownloadUrl` with the WixMedia id and specify the asset_key in the request
                 */
                private?: (boolean | null);
                /**
                 * Key to identify the object relationship to the original media in WixMedia.
                 * Can be used to request a download for the specific asset.
                 * For example: 128-30kbs.mp3, 320kbs.mp3, 128kbs.mp3
                 */
                assetKey?: (string | null);
                /**
                 * Audio format.
                 */
                format?: (string | null);
                /**
                 * Audio quality.
                 */
                quality?: (string | null);
            }
            export interface Document {
                /**
                 * WixMedia ID.
                 */
                id?: (string | null);
                /**
                 * Document URL.
                 */
                url?: (string | null);
                /**
                 * Document URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Document size in bytes.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Document filename.
                 */
                filename?: (string | null);
                /**
                 * Document thumbnail.
                 */
                thumbnail?: ($wrapper.wix.common.Image | null);
            }
            export interface Model3D {
                /**
                 * WixMedia 3D ID.
                 */
                id?: (string | null);
                /**
                 * 3D URL.
                 */
                url?: (string | null);
                /**
                 * 3D thumbnail Image
                 */
                thumbnail?: ($wrapper.wix.common.Image | null);
                /**
                 * 3D alt text.
                 */
                altText?: (string | null);
                /**
                 * 3D URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * 3D filename.
                 */
                filename?: (string | null);
                /**
                 * 3D size in bytes.
                 */
                sizeInBytes?: (string | null);
            }
            export interface Archive {
                /**
                 * WixMedia ID.
                 */
                id?: (string | null);
                /**
                 * Archive URL.
                 */
                url?: (string | null);
                /**
                 * Archive URL expiration date (when relevant).
                 */
                urlExpirationDate?: (Date | null);
                /**
                 * Archive size in bytes.
                 */
                sizeInBytes?: (string | null);
                /**
                 * Archive filename.
                 */
                filename?: (string | null);
            }
            /**
             * Deprecated - Copy this message into your service, do not reference it
             */
            export interface MediaItem {
                /**
                 * WixMedia image
                 */
                image?: ($wrapper.wix.common.Image | null);
                /**
                 * WixMedia video
                 */
                video?: ($wrapper.wix.common.Video | null);
                /**
                 * WixMedia document
                 */
                document?: ($wrapper.wix.common.Document | null);
            }
            export interface FocalPoint {
                /**
                 * X-coordinate of the focal point.
                 */
                x?: (number | null);
                /**
                 * Y-coordinate of the focal point.
                 */
                y?: (number | null);
                /**
                 * crop by height
                 */
                height?: (number | null);
                /**
                 * crop by width
                 */
                width?: (number | null);
            }
            /**
             * Money.
             * Default format to use. Sufficiently compliant with majority of standards: w3c, ISO 4217, ISO 20022, ISO 8583:2003.
             */
            export interface Money {
                /**
                 * Monetary amount. Decimal string with a period as a decimal separator (e.g., 3.99). Optionally, a single (-), to indicate that the amount is negative.
                 */
                value?: (string | null);
                /**
                 * Currency code. Must be valid ISO 4217 currency code (e.g., USD).
                 */
                currency?: (string | null);
                /**
                 * Monetary amount. Decimal string in local format (e.g., 1 000,30). Optionally, a single (-), to indicate that the amount is negative.
                 */
                formattedValue?: (string | null);
            }
            export interface PageUrl {
                /**
                 * The base URL. For premium sites, this is the domain. For free sites, this is the site URL. For example, `mysite.wixsite.com/mysite`.
                 */
                base?: (string | null);
                /**
                 * The relative path for the page within the site. For example, `/product-page/a-product`.
                 */
                path?: (string | null);
            }
            export interface PageUrlV2 {
                /**
                 * The relative path for the page within the site. For example, `/product-page/a-product`.
                 */
                relativePath?: (string | null);
                /**
                 * The page's full URL. For example, `https://mysite.com/product-page/a-product`.
                 */
                url?: (string | null);
            }
            export interface Paging {
                /**
                 * Number of items to load.
                 */
                limit?: (number | null);
                /**
                 * Number of items to skip in the current sort order.
                 */
                offset?: (number | null);
            }
            export interface CursorPaging {
                /**
                 * Maximum number of items to return in the results.
                 */
                limit?: (number | null);
                /**
                 * Pointer to the next or previous page in the list of results.
                 * 
                 * Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response.
                 * Not relevant for the first request.
                 */
                cursor?: (string | null);
            }
            export interface PagingMetadata {
                /**
                 * Number of items returned in the response.
                 */
                count?: (number | null);
                /**
                 * Offset that was requested.
                 */
                offset?: (number | null);
                /**
                 * Total number of items that match the query.
                 */
                total?: (number | null);
                /**
                 * Flag that indicates the server failed to calculate the `total` field.
                 */
                tooManyToCount?: (boolean | null);
                /**
                 * Indicates if there are more results after the current page.
                 * If `true`, another page of results can be retrieved.
                 * If `false`, this is the last page.
                 */
                hasNext?: (boolean | null);
            }
            export interface PagingMetadataV2 {
                /**
                 * Number of items returned in the response.
                 */
                count?: (number | null);
                /**
                 * Offset that was requested.
                 */
                offset?: (number | null);
                /**
                 * Total number of items that match the query. Returned if offset paging is used and the `tooManyToCount` flag is not set.
                 */
                total?: (number | null);
                /**
                 * Flag that indicates the server failed to calculate the `total` field.
                 */
                tooManyToCount?: (boolean | null);
                /**
                 * Cursors to navigate through the result pages using `next` and `prev`. Returned if cursor paging is used.
                 */
                cursors?: ($wrapper.wix.common.Cursors | null);
                /**
                 * Indicates if there are more results after the current page.
                 * If `true`, another page of results can be retrieved.
                 * If `false`, this is the last page.
                 */
                hasNext?: (boolean | null);
            }
            export interface CursorPagingMetadata {
                /**
                 * Number of items returned in current page.
                 */
                count?: (number | null);
                /**
                 * Cursor strings that point to the next page, previous page, or both.
                 */
                cursors?: ($wrapper.wix.common.Cursors | null);
                /**
                 * Whether there are more pages to retrieve following the current page.
                 * 
                 * + `true`: Another page of results can be retrieved.
                 * + `false`: This is the last page.
                 */
                hasNext?: (boolean | null);
                /**
                 * Total number of items matching the filter.
                 * Available only on the first page of *Search* results, not included in *Query* or *List* results.
                 * If the Search results span multiple pages, the value of `total` will exceed the number of items returned on the first page.
                 */
                total?: (number | null);
            }
            export interface Cursors {
                /**
                 * Cursor string pointing to the next page in the list of results.
                 */
                next?: (string | null);
                /**
                 * Cursor pointing to the previous page in the list of results.
                 */
                prev?: (string | null);
            }
            export interface Sorting {
                /**
                 * Name of the field to sort by.
                 */
                fieldName?: (string | null);
                /**
                 * Sort order.
                 */
                order?: ($wrapper.wix.common.SortOrder | null);
                /**
                 * When `field_name` is a property of repeated field that is marked as `MATCH_ITEMS` and sort should be done by
                 * a specific element from a collection, filter can/should be provided to ensure correct sort value is picked.
                 * 
                 * If multiple filters are provided, they are combined with AND operator.
                 * 
                 * Example:
                 * Given we have document like {"id": "1", "nestedField": [{"price": 10, "region": "EU"}, {"price": 20, "region": "US"}]}
                 * and `nestedField` is marked as `MATCH_ITEMS`, to ensure that sorting is done by correct region, filter should be
                 * { fieldName: "nestedField.price", "select_items_by": [{"nestedField.region": "US"}] }
                 */
                selectItemsBy?: ({ [key: string]: any }[] | null);
            }
            export enum SortOrder {
                ASC = "ASC",
                DESC = "DESC",
            }
            export namespace spi {
                export interface SpiBaseUri {
                    /**
                     * Base URI where the methods are called. Wix appends the path to the `baseUri`.
                     * For example, to call the Get Shipping Rates method at `https://my-shipping-provider.com/v1/getRates`, the base URI you provide here is `https://my-shipping-provider.com/`.
                     */
                    baseUri?: (string | null);
                    /**
                     * Alternate, custom URIs to replace the default URIs for specific service plugin methods.
                     */
                    alternativeUris?: ($wrapper.wix.common.spi.SpiBaseUri.AlternativeUri[] | null);
                }
                export namespace SpiBaseUri {
                    export interface AlternativeUri {
                        /**
                         * Name of the method to create a custom URI for.
                         * 
                         * For `methodName`, use the name of the method in PascalCase.
                         * For example, for Get Shipping Rates use `GetShippingRates`.
                         */
                        methodName?: (string | null);
                        /**
                         * Custom URI that Wix uses to call your server for this method. The path-suffix documented in the method will not be appended to this URI.
                         * Must be a secured endpoint beginning with `https://`. For example, `https://www.my-shipping-provider.com/my-shipping-rates`.
                         */
                        absoluteUri?: (string | null);
                    }
                }
                /**
                 * this message is not directly used by any service,
                 * it exists to describe the expected parameters that SHOULD be provided to invoked Velo methods as part of open-platform.
                 * e.g. SPIs, event-handlers, etc..
                 * NOTE: this context object MUST be provided as the last argument in each Velo method signature.
                 * 
                 * Example:
                 * ```typescript
                 * export function wixStores_onOrderCanceled({ event, metadata }: OrderCanceledEvent) {
                 * ...
                 * }
                 * ```
                 */
                export interface Context {
                    /**
                     * A unique identifier of the request. You may print this ID to your logs to help with future debugging and easier correlation with Wix's logs.
                     */
                    requestId?: (string | null);
                    /**
                     * [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) 3-letter currency code.
                     */
                    currency?: (string | null);
                    /**
                     * An object that describes the identity that triggered this request.
                     */
                    identity?: ($wrapper.wix.common.spi.Context.IdentificationData | null);
                    /**
                     * A string representing a language and region in the format of `"xx-XX"`. First 2 letters represent the language code according to ISO 639-1. This is followed by a dash "-", and then a by 2 capital letters representing the region according to ISO 3166-2. For example, `"en-US"`.
                     */
                    languages?: (string[] | null);
                    /**
                     * The service provider app's instance ID.
                     */
                    instanceId?: (string | null);
                    /**
                     * Extension ID in Dev Center.
                     */
                    appExtensionId?: (string | null);
                    /**
                     * Extension type in Dev Center.
                     */
                    appExtensionType?: (string | null);
                    /**
                     * Invoked function.
                     */
                    functionName?: (string | null);
                }
                export namespace Context {
                    export interface IdentificationData {
                        identityType?: ($wrapper.wix.common.spi.Context.IdentificationData.IdentityType | null);
                        /**
                         * ID of a site visitor that has not logged in to the site.
                         */
                        anonymousVisitorId?: (string | null);
                        /**
                         * ID of a site visitor that has logged in to the site.
                         */
                        memberId?: (string | null);
                        /**
                         * ID of a Wix user (site owner, contributor, etc.).
                         */
                        wixUserId?: (string | null);
                        /**
                         * ID of an app.
                         */
                        appId?: (string | null);
                    }
                    export namespace IdentificationData {
                        export enum IdentityType {
                            UNKNOWN = "UNKNOWN",
                            ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
                            MEMBER = "MEMBER",
                            WIX_USER = "WIX_USER",
                            APP = "APP",
                        }
                    }
                }
            }
            export namespace tags {
                /**
                 * Common object for tags.
                 * Should be use as in this example:
                 * message Foo {
                 * string id = 1;
                 * ...
                 * Tags tags = 5
                 * }
                 * 
                 * example of taggable entity
                 * {
                 * id: "123"
                 * tags: {
                 * tags: {
                 * tag_ids:["11","22"]
                 * },
                 * private_tags: {
                 * tag_ids: ["33", "44"]
                 * }
                 * }
                 * }
                 */
                export interface Tags {
                    /**
                     * Tags that require an additional permission in order to access them, normally not given to site members or visitors.
                     */
                    privateTags?: ($wrapper.wix.common.tags.Tags.TagList | null);
                    /**
                     * Tags that are exposed to anyone who has access to the labeled entity itself, including site members and visitors.
                     */
                    tags?: ($wrapper.wix.common.tags.Tags.TagList | null);
                }
                export namespace Tags {
                    export interface TagList {
                        /**
                         * List of tag IDs
                         */
                        tagIds?: (string[] | null);
                    }
                }
                export interface PublicTags {
                    /**
                     * Tags that are exposed to anyone who has access to the labeled entity itself, including site members and visitors.
                     */
                    tags?: ($wrapper.wix.common.tags.PublicTags.TagList | null);
                }
                export namespace PublicTags {
                    export interface TagList {
                        /**
                         * List of tag IDs
                         */
                        tagIds?: (string[] | null);
                    }
                }
            }
            /**
             * The link object generated by panels in the editor and used by applications in Wix
             */
            export interface WixLink {
                /**
                 * External link type
                 */
                external?: ($wrapper.wix.common.ExternalLink | null);
                /**
                 * Page link type
                 */
                page?: ($wrapper.wix.common.PageLink | null);
                /**
                 * Anchor link type
                 */
                anchor?: ($wrapper.wix.common.AnchorLink | null);
                /**
                 * Dynamic page link type
                 */
                dynamicPage?: ($wrapper.wix.common.DynamicPageLink | null);
                /**
                 * Document link type
                 */
                document?: ($wrapper.wix.common.DocumentLink | null);
                /**
                 * Email link type
                 */
                email?: ($wrapper.wix.common.EmailLink | null);
                /**
                 * Phone link type
                 */
                phone?: ($wrapper.wix.common.PhoneLink | null);
                /**
                 * Address link type
                 */
                address?: ($wrapper.wix.common.AddressLink | null);
                /**
                 * WhatsApp link type
                 */
                whatsApp?: ($wrapper.wix.common.WhatsAppLink | null);
                /**
                 * TPA link type
                 */
                tpaPage?: ($wrapper.wix.common.TpaPageLink | null);
            }
            export interface ExternalLink {
                /**
                 * The url of the page
                 */
                url?: (string | null);
                /**
                 * Where this link should open, supports _self and _blank or any name the user chooses. _self means same page, _blank means new page.
                 */
                target?: (string | null);
                /**
                 * rel of link
                 */
                rel?: ($wrapper.wix.common.LinkRel[] | null);
            }
            export interface PageLink {
                /**
                 * The page id we want from the site
                 */
                pageId?: (string | null);
                /**
                 * Where this link should open, supports _self and _blank or any name the user chooses. _self means same page, _blank means new page.
                 */
                target?: (string | null);
                /**
                 * rel of link
                 */
                rel?: ($wrapper.wix.common.LinkRel[] | null);
            }
            export interface AnchorLink {
                /**
                 * The name of the anchor
                 */
                anchorName?: (string | null);
                /**
                 * The data id (from the JSON page) of the anchor that should be used
                 */
                anchorDataId?: (string | null);
                /**
                 * The page id we want from the site
                 */
                pageId?: (string | null);
                /**
                 * rel of link
                 */
                rel?: ($wrapper.wix.common.LinkRel[] | null);
            }
            export interface DynamicPageLink {
                /**
                 * The router that handles this link
                 */
                routerId?: (string | null);
                /**
                 * The path data we'd like
                 */
                innerRoute?: (string | null);
                /**
                 * The data id (from the JSON page) of the anchor that should be used
                 */
                anchorDataId?: (string | null);
                /**
                 * rel of link
                 */
                rel?: ($wrapper.wix.common.LinkRel[] | null);
            }
            export interface DocumentLink {
                /**
                 * The id of the document
                 */
                docId?: (string | null);
                /**
                 * The name of the document for download purposes
                 */
                name?: (string | null);
                /**
                 * If this document can be indexed by scrapers, default is false
                 */
                indexable?: (boolean | null);
            }
            export interface EmailLink {
                /**
                 * The email we will be sending a message to
                 */
                recipient?: (string | null);
                /**
                 * The subject of the email
                 */
                subject?: (string | null);
                /**
                 * The body of the email
                 */
                body?: (string | null);
            }
            export interface PhoneLink {
                /**
                 * The phone number we want to link to
                 */
                phoneNumber?: (string | null);
            }
            export interface AddressLink {
                /**
                 * An address that we can link to
                 */
                address?: (string | null);
            }
            export interface WhatsAppLink {
                /**
                 * The whatsApp phone number we want to connect with
                 */
                phoneNumber?: (string | null);
            }
            /**
             * Link to a TPA page
             */
            export interface TpaPageLink {
                /**
                 * Type of item (e.g. 'wix.stores.sub_pages.product')
                 */
                itemTypeIdentifier?: (string | null);
                /**
                 * Id of linked item
                 */
                itemId?: (string | null);
                /**
                 * Id of linked page
                 */
                pageId?: (string | null);
                /**
                 * Id of app being linked to (AppDefId)
                 */
                appDefinitionId?: (string | null);
                /**
                 * The relativepath of linked page
                 */
                path?: (string | null);
                /**
                 * rel of link
                 */
                rel?: ($wrapper.wix.common.LinkRel[] | null);
            }
            /**
             * The 'rel' attribute of the link. The rel attribute defines the relationship between a linked resource and the current document.
             * Further reading (also about different possible rel types): https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel
             * Following are the accepted 'rel' types by Wix applications.
             */
            export enum LinkRel {
                unknown_link_rel = "unknown_link_rel",
                nofollow = "nofollow",
                noopener = "noopener",
                noreferrer = "noreferrer",
                sponsored = "sponsored",
            }
        }
        export namespace api {
            export interface ReferenceEntityField {
                /**
                 * field path from root of a message annotated with `wix.api.entity` annotation. For example 'item.name'.
                 */
                path?: (string | null);
            }
            export interface CacheSettings {
                /**
                 * default is 604800 seconds = 1 week
                 */
                maxAgeSeconds?: (number | null);
                /**
                 * default is false
                 */
                manual?: (boolean | null);
            }
            export interface FieldSet {
                field?: (string[] | null);
            }
            export interface Deprecated {
                /**
                 * use relative proto FQN as absolute identifier. e.g. "wix.common.Query"
                 */
                replacedBy?: (string | null);
                /**
                 * a human readable sunset date of the deprecated resource YYYY-MM-DD
                 */
                targetRemovalDate?: (string | null);
            }
            export interface Unique {
                field?: (string[] | null);
            }
            export interface Crud {
                /**
                 * method type
                 */
                method?: ($wrapper.wix.api.Crud.Method | null);
                createOptions?: ($wrapper.wix.api.CreateMethodOptions | null);
                getOptions?: ($wrapper.wix.api.GetItemMethodOptions | null);
                updateOptions?: ($wrapper.wix.api.UpdateMethodOptions | null);
                deleteOptions?: ($wrapper.wix.api.DeleteMethodOptions | null);
                listOptions?: ($wrapper.wix.api.ListMethodOptions | null);
                queryOptions?: ($wrapper.wix.api.QueryMethodOptions | null);
                searchOptions?: ($wrapper.wix.api.SearchMethodOptions | null);
                bulkCreateOptions?: ($wrapper.wix.api.BulkCreateMethodOptions | null);
                bulkUpdateOptions?: ($wrapper.wix.api.BulkUpdateMethodOptions | null);
                bulkUpdateByFilterOptions?: ($wrapper.wix.api.BulkUpdateByFilterMethodOptions | null);
                bulkDeleteOptions?: ($wrapper.wix.api.BulkDeleteMethodOptions | null);
                bulkDeleteByFilterOptions?: ($wrapper.wix.api.BulkDeleteByFilterMethodOptions | null);
                upsertOptions?: ($wrapper.wix.api.UpsertMethodOptions | null);
                bulkUpsertOptions?: ($wrapper.wix.api.BulkUpsertMethodOptions | null);
                listDeletedOptions?: ($wrapper.wix.api.ListDeletedMethodOptions | null);
                getDeletedOptions?: ($wrapper.wix.api.GetDeletedMethodOptions | null);
                restoreFromTrashbinOptions?: ($wrapper.wix.api.RestoreFromTrashbinMethodOptions | null);
                removeFromTrashbinOptions?: ($wrapper.wix.api.RemoveFromTrashbinMethodOptions | null);
                countOptions?: ($wrapper.wix.api.CountOptions | null);
                searchRelatedOptions?: ($wrapper.wix.api.SearchRelatedOptions | null);
                updateExtendedFieldsOptions?: ($wrapper.wix.api.UpdateExtendedFieldsOptions | null);
                /**
                 * marks that this method is a custom-action, that unfolds a read/write operation
                 */
                customActionOptions?: ($wrapper.wix.api.CustomActionOptions | null);
                bulkUpdateTagsOptions?: ($wrapper.wix.api.BulkUpdateTagsMethodOptions | null);
                bulkUpdateTagsByFilterOptions?: ($wrapper.wix.api.BulkUpdateTagsByFilterMethodOptions | null);
            }
            export namespace Crud {
                export enum Method {
                    UNKNOWN_METHOD = "UNKNOWN_METHOD",
                    CREATE = "CREATE",
                    GET_ITEM = "GET_ITEM",
                    UPDATE = "UPDATE",
                    DELETE = "DELETE",
                    UPSERT = "UPSERT",
                    LIST = "LIST",
                    QUERY = "QUERY",
                    SEARCH = "SEARCH",
                    BULK_CREATE = "BULK_CREATE",
                    BULK_UPDATE = "BULK_UPDATE",
                    BULK_UPDATE_BY_FILTER = "BULK_UPDATE_BY_FILTER",
                    BULK_DELETE = "BULK_DELETE",
                    BULK_DELETE_BY_FILTER = "BULK_DELETE_BY_FILTER",
                    BULK_UPSERT = "BULK_UPSERT",
                    LIST_DELETED = "LIST_DELETED",
                    GET_DELETED = "GET_DELETED",
                    RESTORE_FROM_TRASHBIN = "RESTORE_FROM_TRASHBIN",
                    REMOVE_FROM_TRASHBIN = "REMOVE_FROM_TRASHBIN",
                    COUNT = "COUNT",
                    SEARCH_RELATED = "SEARCH_RELATED",
                    UPDATE_EXTENDED_FIELDS = "UPDATE_EXTENDED_FIELDS",
                    BULK_UPDATE_TAGS = "BULK_UPDATE_TAGS",
                    BULK_UPDATE_TAGS_BY_FILTER = "BULK_UPDATE_TAGS_BY_FILTER",
                    CUSTOM_ACTION = "CUSTOM_ACTION",
                }
            }
            export interface Paging {
                /**
                 * paging type
                 */
                type?: ($wrapper.wix.api.Paging.Type | null);
                /**
                 * paging field name in response object. default is `metadata`, DEPRECATED in commons V2
                 */
                pagingMetadataField?: (string | null);
                /**
                 * cursor paging field name in response object. default is `cursor_paging_metadata`
                 */
                cursorPagingMetadataField?: (string | null);
                /**
                 * offset paging field name in response object. default is `offset_paging_metadata`
                 */
                offsetPagingMetadataField?: (string | null);
            }
            export namespace Paging {
                export enum Type {
                    UNKNOWN_TYPE = "UNKNOWN_TYPE",
                    OFFSET = "OFFSET",
                    CURSOR = "CURSOR",
                    BOTH = "BOTH",
                }
            }
            export interface CustomActionOptions {
                /**
                 * the custom-action's operation will do nothing but read data.
                 */
                readOperation?: (boolean | null);
                /**
                 * if WQL validation is needed in this method, provide the data needed for the validator
                 */
                wql?: ($wrapper.wix.api.WqlOptions | null);
            }
            export interface WqlOptions {
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
                /**
                 * provide path to filter field (struct) in your request message
                 */
                filterField?: (string | null);
                /**
                 * provide path to query field (wix.common.QueryV2) in your request message
                 */
                queryField?: (string | null);
                /**
                 * provide path to search field (wix.common.Search) in your request message
                 */
                searchField?: (string | null);
            }
            export interface CreateMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
            }
            export interface GetItemMethodOptions {
                /**
                 * item field name in response object only. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * id field name in request object. default is `<entity-name>_id`
                 */
                idField?: (string | null);
            }
            export interface UpdateMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * fieldmask field name in request object. default is `fieldmask`, only if it really exists in model
                 */
                fieldmaskField?: (string | null);
            }
            export interface UpsertMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * fieldmask field name in request object. default is `fieldmask`, only if it really exists in model
                 */
                fieldmaskField?: (string | null);
            }
            export interface DeleteMethodOptions {
                /**
                 * id field name in request object. default is `<entity-name>_id`
                 */
                idField?: (string | null);
            }
            export interface ListMethodOptions {
                /**
                 * ids field name in request object if such exists. recommended field-name: `<entity-name>_ids`
                 */
                idsField?: (string | null);
                /**
                 * items field name in response object.
                 */
                itemsField?: (string | null);
                /**
                 * present paging mechanism info, default will be of type=`CURSOR`
                 */
                paging?: ($wrapper.wix.api.Paging | null);
                /**
                 * collection of FQNs of fields that MAY be aliased with the const `"me"`
                 */
                meAliasableField?: (string[] | null);
            }
            export interface QueryMethodOptions {
                /**
                 * query field name in request object. default is `query`, DEPRECATED in commons V2
                 */
                queryField?: (string | null);
                /**
                 * cursor query field name in request object. default is `cursor_query`
                 */
                cursorQueryField?: (string | null);
                /**
                 * offset query field name in request object. default is `offset_query`
                 */
                offsetQueryField?: (string | null);
                /**
                 * items field name in response object.
                 */
                itemsField?: (string | null);
                /**
                 * present paging mechanism info, default will be of type=`CURSOR`
                 */
                paging?: ($wrapper.wix.api.Paging | null);
                /**
                 * mark fields that are available for filtering and sorting via WixQueryLanguage
                 * Deprecated - use wql annotation on the entity level
                 */
                wql?: ($wrapper.wix.api.Wql | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
                /**
                 * collection of FQNs of fields that MAY be aliased with the const `"me"`
                 */
                meAliasableField?: (string[] | null);
            }
            export interface SearchMethodOptions {
                /**
                 * search field name in request object. default is `search`, DEPRECATED in commons V2
                 */
                searchField?: (string | null);
                /**
                 * cursor search field name in request object. default is `cursor_search`
                 */
                cursorSearchField?: (string | null);
                /**
                 * offset search field name in request object. default is `offset_search`
                 */
                offsetSearchField?: (string | null);
                /**
                 * items field name in response object.
                 */
                itemsField?: (string | null);
                /**
                 * present paging mechanism info, default will be of type=`CURSOR`
                 */
                paging?: ($wrapper.wix.api.Paging | null);
                /**
                 * mark fields that are available for filtering and sorting via WixQueryLanguage
                 */
                wql?: ($wrapper.wix.api.Wql | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
                /**
                 * collection of FQNs of fields that MAY be aliased with the const `"me"`
                 */
                meAliasableField?: (string[] | null);
                /**
                 * mark fields that are available for search
                 */
                search?: ($wrapper.wix.api.Search[] | null);
            }
            export interface BulkCreateMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
            }
            export interface BulkUpdateMethodOptions {
                /**
                 * items field name in request and response objects. default is `<entity-name>` in plural. For the request, the field is expected to be a repeated message that includes entity and fieldmask.
                 */
                itemsField?: (string | null);
                /**
                 * item field name under the message used for the repeated field pointed by items_field. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * fieldmask field name under the message used for the repeated field pointed by items_field. default is `fieldmask`, only if it really exists in model
                 */
                fieldmaskField?: (string | null);
            }
            export interface BulkUpdateByFilterMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * fieldmask field name in request object. default is `fieldmask`, only if it really exists in model
                 */
                fieldmaskField?: (string | null);
                /**
                 * filter field name in request object. default is `filter`
                 */
                filterField?: (string | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
            }
            export interface BulkUpdateTagsMethodOptions {
                /**
                 * ids field name in request object. default is `<entity-name>_ids`
                 */
                idsField?: (string | null);
            }
            export interface BulkUpdateTagsByFilterMethodOptions {
                /**
                 * filter field name in request object. default is `filter`
                 */
                filterField?: (string | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
            }
            export interface BulkUpsertMethodOptions {
                /**
                 * item field name in request and response objects. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * fieldmask field name in request object. default is `fieldmask`, only if it really exists in model
                 */
                fieldmaskField?: (string | null);
            }
            export interface BulkDeleteMethodOptions {
                /**
                 * ids field name in request object. default is `<entity-name>_ids`
                 */
                idsField?: (string | null);
            }
            export interface BulkDeleteByFilterMethodOptions {
                /**
                 * filter field name in request object. default is `filter`
                 */
                filterField?: (string | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
            }
            export interface ListDeletedMethodOptions {
                /**
                 * ids field name in request object if such exists. recommended field-name: `<entity-name>_ids`
                 */
                idsField?: (string | null);
                /**
                 * items field name in response object.
                 */
                itemsField?: (string | null);
                /**
                 * present paging mechanism info, default will be of type=`CURSOR`
                 */
                paging?: ($wrapper.wix.api.Paging | null);
                /**
                 * collection of FQNs of fields that MAY be aliased with the const `"me"`
                 */
                meAliasableField?: (string[] | null);
            }
            export interface GetDeletedMethodOptions {
                /**
                 * item field name in response object only. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * id field name in request object. default is `<entity-name>_id`
                 */
                idField?: (string | null);
            }
            export interface RestoreFromTrashbinMethodOptions {
                /**
                 * item field name in response object only. default is `<entity-name>`
                 */
                itemField?: (string | null);
                /**
                 * id field name in request object. default is `<entity-name>_id`
                 */
                idField?: (string | null);
            }
            export interface RemoveFromTrashbinMethodOptions {
                /**
                 * id field name in request object. default is `<entity-name>_id`
                 */
                idField?: (string | null);
            }
            export interface CountOptions {
                /**
                 * The name of the endpoint that the count "copy" the WQL settings from - e.g inherit_wql_from: 'QueryProducts'
                 * Usually, that will be the query endpoint since you want the same filter capabilities for query and count
                 */
                inheritWqlFrom?: (string | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
                /**
                 * query field name in request object. default is `filter`
                 */
                filterField?: (string | null);
                /**
                 * count field name in response object. default is `count`
                 */
                countField?: (string | null);
            }
            export interface SearchRelatedOptions {
                /**
                 * The name of the endpoint that the related-search "copy" the WQL settings from - e.g inherit_wql_from: 'SearchProducts'
                 * Usually, that will be the search endpoint since you want the same filter capabilities for search and related search
                 */
                inheritWqlFrom?: (string | null);
                /**
                 * Name of WQL variant to use
                 */
                queryOptionsName?: (string | null);
            }
            export interface UpdateExtendedFieldsOptions {
                /**
                 * item field name in response object only. default is `<entity-name>`
                 */
                itemField?: (string | null);
            }
            export interface Wql {
                /**
                 * this field is deprecated due to a better and shorter naming
                 */
                operatorFieldSupport?: ($wrapper.wix.api.Wql.OperatorFieldSupport[] | null);
                /**
                 * supported operators for subject query method
                 */
                pattern?: ($wrapper.wix.api.Wql.OperatorFieldSupport[] | null);
                /**
                 * false by default. all new services will have it set to true
                 */
                validateQuery?: (boolean | null);
            }
            export namespace Wql {
                export enum Operator {
                    ALL_APPLICABLE_OPERATORS = "ALL_APPLICABLE_OPERATORS",
                    EQ = "EQ",
                    GT = "GT",
                    GTE = "GTE",
                    IN = "IN",
                    LT = "LT",
                    LTE = "LTE",
                    NE = "NE",
                    NIN = "NIN",
                    BEGINS = "BEGINS",
                    EXISTS = "EXISTS",
                    HAS_ALL = "HAS_ALL",
                    ALL = "ALL",
                    HAS_SOME = "HAS_SOME",
                    ANY = "ANY",
                    EMPTY = "EMPTY",
                    MATCH_ALL = "MATCH_ALL",
                    MATCH_ITEMS = "MATCH_ITEMS",
                    ENHANCED_DATE = "ENHANCED_DATE",
                }
                export enum Sort {
                    NONE = "NONE",
                    ASC = "ASC",
                    DESC = "DESC",
                    BOTH = "BOTH",
                }
                export interface RequiredFields {
                    /**
                     * this field is deprecated because we need sort direction alongside to field path
                     */
                    field?: (string[] | null);
                    /**
                     * all required field configurations to satisfy composite index
                     */
                    requiredField?: ($wrapper.wix.api.Wql.RequiredFields.RequiredField[] | null);
                }
                export namespace RequiredFields {
                    export interface RequiredField {
                        /**
                         * a field path that accepts this operator
                         */
                        path?: (string | null);
                        /**
                         * sort type enabled for this glob
                         */
                        sort?: ($wrapper.wix.api.Wql.Sort | null);
                    }
                }
                export enum VirtualSubfields {
                    NO_VIRTUAL_SUBFIELDS = "NO_VIRTUAL_SUBFIELDS",
                    DATE = "DATE",
                    EMAIL = "EMAIL",
                    DATE_TIME = "DATE_TIME",
                }
                export interface OperatorFieldSupport {
                    /**
                     * Operators supported for fields that match the glob
                     */
                    operator?: ($wrapper.wix.api.Wql.Operator[] | null);
                    /**
                     * this field is deprecated because glob is hard to read. moved to a direct field config approach
                     */
                    glob?: (string | null);
                    /**
                     * a collection of field paths that accepts this operator
                     */
                    field?: (string[] | null);
                    /**
                     * sort type enabled for this glob
                     */
                    sort?: ($wrapper.wix.api.Wql.Sort | null);
                    /**
                     * fields that match this glob, can be used only if the query is also filtered by required_fields
                     */
                    requiredFields?: ($wrapper.wix.api.Wql.RequiredFields[] | null);
                    maturity?: ($wrapper.wix.api.Maturity | null);
                    /**
                     * kind of virtual subfields are supported for this field
                     */
                    virtualSubfields?: ($wrapper.wix.api.Wql.VirtualSubfields | null);
                }
            }
            export interface Search {
                /**
                 * a collection of field paths that supports Free Text Search
                 */
                field?: (string[] | null);
                maturity?: ($wrapper.wix.api.Maturity | null);
            }
            export interface Translatable {
                /**
                 * a human friendly field name
                 */
                name?: (string | null);
                /**
                 * is this translatable field hidden in Multilingual
                 */
                hidden?: (boolean | null);
                /**
                 * fields in schema may be grouped under meaningful topic or category of the source entity
                 */
                grouping?: (string | null);
                /**
                 * translation input component type e.g. "freetext", "dropdown", etc..
                 */
                type?: ($wrapper.wix.api.Translatable.Type | null);
                /**
                 * is this field for preview and not translatable
                 */
                displayOnly?: (boolean | null);
            }
            export namespace Translatable {
                export enum Type {
                    UNDEFINED_TYPE = "UNDEFINED_TYPE",
                    SHORT_TEXT = "SHORT_TEXT",
                    LONG_TEXT = "LONG_TEXT",
                    RICH_TEXT = "RICH_TEXT",
                    RICH_CONTENT_EDITOR = "RICH_CONTENT_EDITOR",
                    SELECTION = "SELECTION",
                    MULTI_SELECTION = "MULTI_SELECTION",
                    DOCUMENT = "DOCUMENT",
                    IMAGE = "IMAGE",
                    VIDEO = "VIDEO",
                    IMAGE_LINK = "IMAGE_LINK",
                }
            }
            export interface Conditional {
                /**
                 * field will not be returned by the server, unless the client has this permission. If `requested_field` is also set, and a client explicitly requests this field but does not have permission, server will return 403-Forbidden error
                 */
                permission?: (string | null);
                /**
                 * field will not be returned by the server, unless the client explicitly requested it using `fields` parameter in the request, with the enum value specified by this annotation
                 */
                requestedField?: (string | null);
            }
            export interface ServiceAppendix {
                /**
                 * appendix type
                 */
                type?: ($wrapper.wix.api.ServiceAppendix.Type | null);
                /**
                 * absolute from module root
                 */
                path?: (string | null);
            }
            export namespace ServiceAppendix {
                export enum Type {
                    UNKNOWN_APPENDIX_TYPE = "UNKNOWN_APPENDIX_TYPE",
                    NILE = "NILE",
                    MESSAGE_BUS = "MESSAGE_BUS",
                }
            }
            /**
             * Defines the target audience of your API
             * @see https://dev.wix.com/docs/rnd-general/articles/p13n-guidelines-aips/guidance-aips/api-lifecycle/2005-exposure
             */
            export enum Exposure {
                PRIVATE = "PRIVATE",
                INTERNAL = "INTERNAL",
                PUBLIC = "PUBLIC",
            }
            export enum Maturity {
                ALPHA = "ALPHA",
                BETA = "BETA",
                IA = "IA",
                GA = "GA",
                NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
            }
            /**
             * Defines which identity audiences are allowed to call this method.
             * 
             * Example usage:
             * rpc UpdateSomething(UpdateSomethingRequest) returns (UpdateSomethingResponse) {
             * option (wix.api.audience) = {
             * uou: { access: MEMBERS_AND_VISITORS }
             * apps: { access: WIX_AND_PUBLIC_APPS }
             * users: { access: ALLOWED }
             * bo_users: { access: NOT_ALLOWED }
             * anonymous: { access: NOT_ALLOWED }
             * };
             * }
             */
            export interface Audience {
                uou?: ($wrapper.wix.api.Audience.Uou | null);
                apps?: ($wrapper.wix.api.Audience.Apps | null);
                users?: ($wrapper.wix.api.Audience.Users | null);
                boUsers?: ($wrapper.wix.api.Audience.BoUsers | null);
                anonymous?: ($wrapper.wix.api.Audience.Anonymous | null);
            }
            export namespace Audience {
                export interface Uou {
                    /**
                     * Level of access for UoU identities.
                     */
                    access?: ($wrapper.wix.api.Audience.Uou.Access | null);
                }
                export namespace Uou {
                    export enum Access {
                        NOT_ALLOWED = "NOT_ALLOWED",
                        MEMBER_ONLY = "MEMBER_ONLY",
                        MEMBERS_AND_VISITORS = "MEMBERS_AND_VISITORS",
                    }
                }
                export interface Apps {
                    /**
                     * Level of access for app identities (TPAs / Wix-apps).
                     */
                    access?: ($wrapper.wix.api.Audience.Apps.Access | null);
                }
                export namespace Apps {
                    export enum Access {
                        NOT_ALLOWED = "NOT_ALLOWED",
                        WIX_APPS_ONLY = "WIX_APPS_ONLY",
                        WIX_AND_PUBLIC_APPS = "WIX_AND_PUBLIC_APPS",
                    }
                }
                export interface Users {
                    /**
                     * Level of access for Wix users/employees.
                     */
                    access?: ($wrapper.wix.api.Audience.Users.Access | null);
                }
                export namespace Users {
                    export enum Access {
                        NOT_ALLOWED = "NOT_ALLOWED",
                        ALLOWED = "ALLOWED",
                    }
                }
                export interface BoUsers {
                    /**
                     * Level of access for Wix users/employees.
                     */
                    access?: ($wrapper.wix.api.Audience.BoUsers.Access | null);
                }
                export namespace BoUsers {
                    export enum Access {
                        NOT_ALLOWED = "NOT_ALLOWED",
                        ALLOWED = "ALLOWED",
                    }
                }
                export interface Anonymous {
                    /**
                     * Level of access for anonymous clients (with no identity).
                     * Requires opt-out from a Flynt rule.
                     */
                    access?: ($wrapper.wix.api.Audience.Anonymous.Access | null);
                }
                export namespace Anonymous {
                    export enum Access {
                        NOT_ALLOWED = "NOT_ALLOWED",
                        ALLOWED = "ALLOWED",
                    }
                }
            }
            /**
             * Indicates the tenancy context of this method.
             * 
             * Note: this is named TenancyOptions (not Tenancy) because `wix.api` already contains
             * an `enum Tenancy` used by callbacks/events.
             * 
             * Override order:
             * - `(wix.api.entity).tenancy` on the main entity (default, see `wix/api/entity.proto`)
             * - `(wix.api.service_tenancy)` on the service (overrides entity)
             * - `(wix.api.tenancy)` on the method (overrides service/entity)
             * 
             * Example usage:
             * rpc UpdateSomething(UpdateSomethingRequest) returns (UpdateSomethingResponse) {
             * option (wix.api.tenancy).type = SITE;
             * }
             */
            export interface TenancyOptions {
                type?: ($wrapper.wix.api.TenancyOptions.Type | null);
            }
            export namespace TenancyOptions {
                export enum Type {
                    SITE = "SITE",
                    ACCOUNT = "ACCOUNT",
                    ORGANIZATION = "ORGANIZATION",
                    CUSTOM = "CUSTOM",
                    INSTANCE = "INSTANCE",
                }
            }
            /**
             * Decimal value validation rules.
             * Based on java.math.BigDecimal, implies (wix.api.format) = DECIMAL_VALUE
             */
            export interface DecimalValueOptions {
                /**
                 * less than or equal
                 */
                lte?: (string | null);
                /**
                 * greater than or equal
                 */
                gte?: (string | null);
                /**
                 * less than
                 */
                lt?: (string | null);
                /**
                 * greater than
                 */
                gt?: (string | null);
                /**
                 * max number of fractional digits
                 */
                maxScale?: (number | null);
            }
            export interface AlignedWithEnum {
                field?: (string | null);
                /**
                 * defaults to _options if not specified
                 */
                suffix?: (string | null);
                /**
                 * By default, when the enum field is updated to a value that has no corresponding
                 * message option within the `oneof`, the framework automatically clears the `oneof`.
                 * This cleanup is achieved by programmatically adding the `oneof` field's path to the
                 * update mask. Set `skip_empty_options_handling` to `true` to disable this behavior.
                 */
                skipEmptyOptionsHandling?: (boolean | null);
            }
            export enum Format {
                EMAIL = "EMAIL",
                HOSTNAME = "HOSTNAME",
                IPV4 = "IPV4",
                IPV6 = "IPV6",
                URI = "URI",
                WEB_URL = "WEB_URL",
                PHONE = "PHONE",
                CREDIT_CARD = "CREDIT_CARD",
                GUID = "GUID",
                COUNTRY = "COUNTRY",
                LANGUAGE = "LANGUAGE",
                DECIMAL_VALUE = "DECIMAL_VALUE",
                CURRENCY = "CURRENCY",
                LANGUAGE_TAG = "LANGUAGE_TAG",
                COLOR_HEX = "COLOR_HEX",
                LOCAL_DATE = "LOCAL_DATE",
                LOCAL_TIME = "LOCAL_TIME",
                LOCAL_DATE_TIME = "LOCAL_DATE_TIME",
                URL_SLUG = "URL_SLUG",
                SYSTEM_SLUG = "SYSTEM_SLUG",
                SECURE_WEB_URL = "SECURE_WEB_URL",
                SUBDIVISION = "SUBDIVISION",
            }
            /**
             * ApplicationError: named Error for backwards compatibility
             */
            export interface Error {
                httpCode?: ($wrapper.wix.api.StatusCodes.HttpStatusCode | null);
                applicationCode?: (string | null);
                /**
                 * FQN path to the message that will be sent as payload for this error
                 */
                data?: (string | null);
            }
            /**
             * Method-level reference to a service-level error.
             */
            export interface ErrorRef {
                /**
                 * Must match existing service-level error application code.
                 */
                applicationCode?: (string | null);
            }
            /**
             * CustomValidationError: field level validation, only declare when you have specific validation in your service that is not coming from infra
             */
            export interface CustomValidationError {
                ruleName?: (string | null);
                /**
                 * FQN path to the message that will be sent as payload for this error
                 */
                data?: (string | null);
            }
            /**
             * InheritCrudErrors: does this method throw standard crud errors?
             */
            export interface InheritCrudErrors {
                /**
                 * types of crud methods to inherit default errors from
                 */
                method?: ($wrapper.wix.api.Crud.Method | null);
            }
            export interface StatusCodes {
            }
            export namespace StatusCodes {
                export enum HttpStatusCode {
                    OK = "OK",
                    UNAUTHENTICATED = "UNAUTHENTICATED",
                    PERMISSION_DENIED = "PERMISSION_DENIED",
                    INVALID_ARGUMENT = "INVALID_ARGUMENT",
                    NOT_FOUND = "NOT_FOUND",
                    INTERNAL = "INTERNAL",
                    UNAVAILABLE = "UNAVAILABLE",
                    RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED",
                    CANCELED = "CANCELED",
                    ALREADY_EXISTS = "ALREADY_EXISTS",
                    FAILED_PRECONDITION = "FAILED_PRECONDITION",
                }
            }
            export interface Details {
                applicationError?: ($wrapper.wix.api.ApplicationError | null);
                validationError?: ($wrapper.wix.api.ValidationError | null);
                systemError?: ($wrapper.wix.api.SystemError | null);
                /**
                 * deprecated in API's - to enable migration from rendering arbitrary tracing to rest response
                 */
                tracing?: ({ [k: string]: string } | null);
            }
            export interface ApplicationError {
                /**
                 * Error code.
                 */
                code?: (string | null);
                /**
                 * Description of the error.
                 */
                description?: (string | null);
                /**
                 * Data related to the error.
                 */
                data?: ({ [key: string]: any } | null);
            }
            export interface SystemError {
                /**
                 * Error code.
                 */
                errorCode?: (string | null);
            }
            /**
             * example result:
             * {
             * "fieldViolations": [
             * {
             * "field": "fieldA",
             * "description": "invalid music note. supported notes: [do,re,mi,fa,sol,la,ti]",
             * "violatedRule": "OTHER",
             * "ruleName": "INVALID_NOTE",
             * "data": {
             * "value": "FI"
             * }
             * },
             * {
             * "field": "fieldB",
             * "description": "field value out of range. supported range: [0-20]",
             * "violatedRule": "MAX",
             * "data": {
             * "threshold": 20
             * }
             * },
             * {
             * "field": "fieldC",
             * "description": "invalid phone number. provide a valid phone number of size: [7-12], supported characters: [0-9, +, -, (, )]",
             * "violatedRule": "FORMAT",
             * "data": {
             * "type": "PHONE"
             * }
             * }
             * ]
             * }
             */
            export interface ValidationError {
                fieldViolations?: ($wrapper.wix.api.ValidationError.FieldViolation[] | null);
            }
            export namespace ValidationError {
                export enum RuleType {
                    VALIDATION = "VALIDATION",
                    OTHER = "OTHER",
                    MAX = "MAX",
                    MIN = "MIN",
                    MAX_LENGTH = "MAX_LENGTH",
                    MIN_LENGTH = "MIN_LENGTH",
                    MAX_SIZE = "MAX_SIZE",
                    MIN_SIZE = "MIN_SIZE",
                    FORMAT = "FORMAT",
                    DECIMAL_LTE = "DECIMAL_LTE",
                    DECIMAL_GTE = "DECIMAL_GTE",
                    DECIMAL_LT = "DECIMAL_LT",
                    DECIMAL_GT = "DECIMAL_GT",
                    DECIMAL_MAX_SCALE = "DECIMAL_MAX_SCALE",
                    INVALID_ENUM_VALUE = "INVALID_ENUM_VALUE",
                    REQUIRED_FIELD = "REQUIRED_FIELD",
                    FIELD_NOT_ALLOWED = "FIELD_NOT_ALLOWED",
                    ONE_OF_ALIGNMENT = "ONE_OF_ALIGNMENT",
                    EXACT_LENGTH = "EXACT_LENGTH",
                    EXACT_SIZE = "EXACT_SIZE",
                    REQUIRED_ONE_OF_FIELD = "REQUIRED_ONE_OF_FIELD",
                }
                export interface FieldViolation {
                    field?: (string | null);
                    description?: (string | null);
                    violatedRule?: ($wrapper.wix.api.ValidationError.RuleType | null);
                    /**
                     * applicable when violated_rule=OTHER
                     */
                    ruleName?: (string | null);
                    data?: ({ [key: string]: any } | null);
                }
            }
            /**
             * for all kinds of min/max violations - match to type provided in annotation
             */
            export interface LimitRuleInt32DataPayload {
                threshold?: (number | null);
            }
            /**
             * for all kinds of min/max violations - match to type provided in annotation
             */
            export interface LimitRuleDoubleDataPayload {
                threshold?: (number | null);
            }
            /**
             * for all kinds of min/max violations - match to type provided in annotation
             */
            export interface LimitRuleStringDataPayload {
                threshold?: (string | null);
            }
            /**
             * for format violations
             */
            export interface FormatRuleDataPayload {
                type?: (string | null);
            }
            /**
             * for enum violations
             */
            export interface EnumRuleDataPayload {
                supported?: (string[] | null);
            }
            /**
             * for required one-of violations
             */
            export interface RequiredOneOfRuleDataPayload {
                supported?: (string[] | null);
            }
        }
    }
    export namespace google {
        export namespace protobuf {
            /**
             * The protocol compiler can output a FileDescriptorSet containing the .proto
             * files it parses.
             */
            export interface FileDescriptorSet {
                file?: ($wrapper.google.protobuf.FileDescriptorProto[] | null);
            }
            /**
             * Describes a complete .proto file.
             */
            export interface FileDescriptorProto {
                /**
                 * file name, relative to root of source tree
                 */
                name?: (string | null);
                /**
                 * e.g. "foo", "foo.bar", etc.
                 */
                package?: (string | null);
                /**
                 * Names of files imported by this file.
                 */
                dependency?: (string[] | null);
                /**
                 * Indexes of the public imported files in the dependency list above.
                 */
                publicDependency?: (number[] | null);
                /**
                 * Indexes of the weak imported files in the dependency list.
                 * For Google-internal migration only. Do not use.
                 */
                weakDependency?: (number[] | null);
                /**
                 * All top-level definitions in this file.
                 */
                messageType?: ($wrapper.google.protobuf.DescriptorProto[] | null);
                enumType?: ($wrapper.google.protobuf.EnumDescriptorProto[] | null);
                service?: ($wrapper.google.protobuf.ServiceDescriptorProto[] | null);
                extension?: ($wrapper.google.protobuf.FieldDescriptorProto[] | null);
                options?: ($wrapper.google.protobuf.FileOptions | null);
                /**
                 * This field contains optional information about the original source code.
                 * You may safely remove this entire field without harming runtime
                 * functionality of the descriptors -- the information is needed only by
                 * development tools.
                 */
                sourceCodeInfo?: ($wrapper.google.protobuf.SourceCodeInfo | null);
                /**
                 * The syntax of the proto file.
                 * The supported values are "proto2" and "proto3".
                 */
                syntax?: (string | null);
            }
            /**
             * Describes a message type.
             */
            export interface DescriptorProto {
                name?: (string | null);
                field?: ($wrapper.google.protobuf.FieldDescriptorProto[] | null);
                extension?: ($wrapper.google.protobuf.FieldDescriptorProto[] | null);
                nestedType?: ($wrapper.google.protobuf.DescriptorProto[] | null);
                enumType?: ($wrapper.google.protobuf.EnumDescriptorProto[] | null);
                extensionRange?: ($wrapper.google.protobuf.DescriptorProto.ExtensionRange[] | null);
                oneofDecl?: ($wrapper.google.protobuf.OneofDescriptorProto[] | null);
                options?: ($wrapper.google.protobuf.MessageOptions | null);
                reservedRange?: ($wrapper.google.protobuf.DescriptorProto.ReservedRange[] | null);
                /**
                 * Reserved field names, which may not be used by fields in the same message.
                 * A given name may only be reserved once.
                 */
                reservedName?: (string[] | null);
            }
            export namespace DescriptorProto {
                export interface ExtensionRange {
                    /**
                     * Inclusive.
                     */
                    start?: (number | null);
                    /**
                     * Exclusive.
                     */
                    end?: (number | null);
                    options?: ($wrapper.google.protobuf.ExtensionRangeOptions | null);
                }
                /**
                 * Range of reserved tag numbers. Reserved tag numbers may not be used by
                 * fields or extension ranges in the same message. Reserved ranges may
                 * not overlap.
                 */
                export interface ReservedRange {
                    /**
                     * Inclusive.
                     */
                    start?: (number | null);
                    /**
                     * Exclusive.
                     */
                    end?: (number | null);
                }
            }
            export interface ExtensionRangeOptions {
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
            }
            /**
             * Describes a field within a message.
             */
            export interface FieldDescriptorProto {
                name?: (string | null);
                number?: (number | null);
                label?: ($wrapper.google.protobuf.FieldDescriptorProto.Label | null);
                /**
                 * If type_name is set, this need not be set.  If both this and type_name
                 * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
                 */
                type?: ($wrapper.google.protobuf.FieldDescriptorProto.Type | null);
                /**
                 * For message and enum types, this is the name of the type.  If the name
                 * starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
                 * rules are used to find the type (i.e. first the nested types within this
                 * message are searched, then within the parent, on up to the root
                 * namespace).
                 */
                typeName?: (string | null);
                /**
                 * For extensions, this is the name of the type being extended.  It is
                 * resolved in the same manner as type_name.
                 */
                extendee?: (string | null);
                /**
                 * For numeric types, contains the original text representation of the value.
                 * For booleans, "true" or "false".
                 * For strings, contains the default text contents (not escaped in any way).
                 * For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
                 * TODO(kenton):  Base-64 encode?
                 */
                defaultValue?: (string | null);
                /**
                 * If set, gives the index of a oneof in the containing type's oneof_decl
                 * list.  This field is a member of that oneof.
                 */
                oneofIndex?: (number | null);
                /**
                 * JSON name of this field. The value is set by protocol compiler. If the
                 * user has set a "json_name" option on this field, that option's value
                 * will be used. Otherwise, it's deduced from the field's name by converting
                 * it to camelCase.
                 */
                jsonName?: (string | null);
                options?: ($wrapper.google.protobuf.FieldOptions | null);
                /**
                 * If true, this is a proto3 "optional". When a proto3 field is optional, it
                 * tracks presence regardless of field type.
                 * 
                 * When proto3_optional is true, this field must be belong to a oneof to
                 * signal to old proto3 clients that presence is tracked for this field. This
                 * oneof is known as a "synthetic" oneof, and this field must be its sole
                 * member (each proto3 optional field gets its own synthetic oneof). Synthetic
                 * oneofs exist in the descriptor only, and do not generate any API. Synthetic
                 * oneofs must be ordered after all "real" oneofs.
                 * 
                 * For message fields, proto3_optional doesn't create any semantic change,
                 * since non-repeated message fields always track presence. However it still
                 * indicates the semantic detail of whether the user wrote "optional" or not.
                 * This can be useful for round-tripping the .proto file. For consistency we
                 * give message fields a synthetic oneof also, even though it is not required
                 * to track presence. This is especially important because the parser can't
                 * tell if a field is a message or an enum, so it must always create a
                 * synthetic oneof.
                 * 
                 * Proto2 optional fields do not set this flag, because they already indicate
                 * optional with `LABEL_OPTIONAL`.
                 */
                proto3Optional?: (boolean | null);
            }
            export namespace FieldDescriptorProto {
                export enum Type {
                    TYPE_DOUBLE = "TYPE_DOUBLE",
                    TYPE_FLOAT = "TYPE_FLOAT",
                    TYPE_INT64 = "TYPE_INT64",
                    TYPE_UINT64 = "TYPE_UINT64",
                    TYPE_INT32 = "TYPE_INT32",
                    TYPE_FIXED64 = "TYPE_FIXED64",
                    TYPE_FIXED32 = "TYPE_FIXED32",
                    TYPE_BOOL = "TYPE_BOOL",
                    TYPE_STRING = "TYPE_STRING",
                    TYPE_GROUP = "TYPE_GROUP",
                    TYPE_MESSAGE = "TYPE_MESSAGE",
                    TYPE_BYTES = "TYPE_BYTES",
                    TYPE_UINT32 = "TYPE_UINT32",
                    TYPE_ENUM = "TYPE_ENUM",
                    TYPE_SFIXED32 = "TYPE_SFIXED32",
                    TYPE_SFIXED64 = "TYPE_SFIXED64",
                    TYPE_SINT32 = "TYPE_SINT32",
                    TYPE_SINT64 = "TYPE_SINT64",
                }
                export enum Label {
                    LABEL_OPTIONAL = "LABEL_OPTIONAL",
                    LABEL_REQUIRED = "LABEL_REQUIRED",
                    LABEL_REPEATED = "LABEL_REPEATED",
                }
            }
            /**
             * Describes a oneof.
             */
            export interface OneofDescriptorProto {
                name?: (string | null);
                options?: ($wrapper.google.protobuf.OneofOptions | null);
            }
            /**
             * Describes an enum type.
             */
            export interface EnumDescriptorProto {
                name?: (string | null);
                value?: ($wrapper.google.protobuf.EnumValueDescriptorProto[] | null);
                options?: ($wrapper.google.protobuf.EnumOptions | null);
                /**
                 * Range of reserved numeric values. Reserved numeric values may not be used
                 * by enum values in the same enum declaration. Reserved ranges may not
                 * overlap.
                 */
                reservedRange?: ($wrapper.google.protobuf.EnumDescriptorProto.EnumReservedRange[] | null);
                /**
                 * Reserved enum value names, which may not be reused. A given name may only
                 * be reserved once.
                 */
                reservedName?: (string[] | null);
            }
            export namespace EnumDescriptorProto {
                /**
                 * Range of reserved numeric values. Reserved values may not be used by
                 * entries in the same enum. Reserved ranges may not overlap.
                 * 
                 * Note that this is distinct from DescriptorProto.ReservedRange in that it
                 * is inclusive such that it can appropriately represent the entire int32
                 * domain.
                 */
                export interface EnumReservedRange {
                    /**
                     * Inclusive.
                     */
                    start?: (number | null);
                    /**
                     * Inclusive.
                     */
                    end?: (number | null);
                }
            }
            /**
             * Describes a value within an enum.
             */
            export interface EnumValueDescriptorProto {
                name?: (string | null);
                number?: (number | null);
                options?: ($wrapper.google.protobuf.EnumValueOptions | null);
            }
            /**
             * Describes a service.
             */
            export interface ServiceDescriptorProto {
                name?: (string | null);
                method?: ($wrapper.google.protobuf.MethodDescriptorProto[] | null);
                options?: ($wrapper.google.protobuf.ServiceOptions | null);
            }
            /**
             * Describes a method of a service.
             */
            export interface MethodDescriptorProto {
                name?: (string | null);
                /**
                 * Input and output type names.  These are resolved in the same way as
                 * FieldDescriptorProto.type_name, but must refer to a message type.
                 */
                inputType?: (string | null);
                outputType?: (string | null);
                options?: ($wrapper.google.protobuf.MethodOptions | null);
                /**
                 * Identifies if client streams multiple client messages
                 */
                clientStreaming?: (boolean | null);
                /**
                 * Identifies if server streams multiple server messages
                 */
                serverStreaming?: (boolean | null);
            }
            export interface FileOptions {
                /**
                 * Sets the Java package where classes generated from this .proto will be
                 * placed.  By default, the proto package is used, but this is often
                 * inappropriate because proto packages do not normally start with backwards
                 * domain names.
                 */
                javaPackage?: (string | null);
                /**
                 * Controls the name of the wrapper Java class generated for the .proto file.
                 * That class will always contain the .proto file's getDescriptor() method as
                 * well as any top-level extensions defined in the .proto file.
                 * If java_multiple_files is disabled, then all the other classes from the
                 * .proto file will be nested inside the single wrapper outer class.
                 */
                javaOuterClassname?: (string | null);
                /**
                 * If enabled, then the Java code generator will generate a separate .java
                 * file for each top-level message, enum, and service defined in the .proto
                 * file.  Thus, these types will *not* be nested inside the wrapper class
                 * named by java_outer_classname.  However, the wrapper class will still be
                 * generated to contain the file's getDescriptor() method as well as any
                 * top-level extensions defined in the file.
                 */
                javaMultipleFiles?: (boolean | null);
                /**
                 * This option does nothing.
                 */
                javaGenerateEqualsAndHash?: (boolean | null);
                /**
                 * If set true, then the Java2 code generator will generate code that
                 * throws an exception whenever an attempt is made to assign a non-UTF-8
                 * byte sequence to a string field.
                 * Message reflection will do the same.
                 * However, an extension field still accepts non-UTF-8 byte sequences.
                 * This option has no effect on when used with the lite runtime.
                 */
                javaStringCheckUtf8?: (boolean | null);
                optimizeFor?: ($wrapper.google.protobuf.FileOptions.OptimizeMode | null);
                /**
                 * Sets the Go package where structs generated from this .proto will be
                 * placed. If omitted, the Go package will be derived from the following:
                 * - The basename of the package import path, if provided.
                 * - Otherwise, the package statement in the .proto file, if present.
                 * - Otherwise, the basename of the .proto file, without extension.
                 */
                goPackage?: (string | null);
                /**
                 * Should generic services be generated in each language?  "Generic" services
                 * are not specific to any particular RPC system.  They are generated by the
                 * main code generators in each language (without additional plugins).
                 * Generic services were the only kind of service generation supported by
                 * early versions of google.protobuf.
                 * 
                 * Generic services are now considered deprecated in favor of using plugins
                 * that generate code specific to your particular RPC system.  Therefore,
                 * these default to false.  Old code which depends on generic services should
                 * explicitly set them to true.
                 */
                ccGenericServices?: (boolean | null);
                javaGenericServices?: (boolean | null);
                pyGenericServices?: (boolean | null);
                phpGenericServices?: (boolean | null);
                /**
                 * Is this file deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for everything in the file, or it will be completely ignored; in the very
                 * least, this is a formalization for deprecating files.
                 */
                deprecated?: (boolean | null);
                /**
                 * Enables the use of arenas for the proto messages in this file. This applies
                 * only to generated classes for C++.
                 */
                ccEnableArenas?: (boolean | null);
                /**
                 * Sets the objective c class prefix which is prepended to all objective c
                 * generated classes from this .proto. There is no default.
                 */
                objcClassPrefix?: (string | null);
                /**
                 * Namespace for generated classes; defaults to the package.
                 */
                csharpNamespace?: (string | null);
                /**
                 * By default Swift generators will take the proto package and CamelCase it
                 * replacing '.' with underscore and use that to prefix the types/symbols
                 * defined. When this options is provided, they will use this value instead
                 * to prefix the types/symbols defined.
                 */
                swiftPrefix?: (string | null);
                /**
                 * Sets the php class prefix which is prepended to all php generated classes
                 * from this .proto. Default is empty.
                 */
                phpClassPrefix?: (string | null);
                /**
                 * Use this option to change the namespace of php generated classes. Default
                 * is empty. When this option is empty, the package name will be used for
                 * determining the namespace.
                 */
                phpNamespace?: (string | null);
                /**
                 * Use this option to change the namespace of php generated metadata classes.
                 * Default is empty. When this option is empty, the proto file name will be
                 * used for determining the namespace.
                 */
                phpMetadataNamespace?: (string | null);
                /**
                 * Use this option to change the package of ruby generated classes. Default
                 * is empty. When this option is not set, the package name will be used for
                 * determining the ruby package.
                 */
                rubyPackage?: (string | null);
                /**
                 * The parser stores options it doesn't recognize here.
                 * See the documentation for the "Options" section above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
            }
            export namespace FileOptions {
                /**
                 * Generated classes can be optimized for speed or code size.
                 */
                export enum OptimizeMode {
                    SPEED = "SPEED",
                    CODE_SIZE = "CODE_SIZE",
                    LITE_RUNTIME = "LITE_RUNTIME",
                }
            }
            export interface MessageOptions {
                /**
                 * Set true to use the old proto1 MessageSet wire format for extensions.
                 * This is provided for backwards-compatibility with the MessageSet wire
                 * format.  You should not use this for any other reason:  It's less
                 * efficient, has fewer features, and is more complicated.
                 * 
                 * The message must be defined exactly as follows:
                 * message Foo {
                 * option message_set_wire_format = true;
                 * extensions 4 to max;
                 * }
                 * Note that the message cannot have any defined fields; MessageSets only
                 * have extensions.
                 * 
                 * All extensions of your type must be singular messages; e.g. they cannot
                 * be int32s, enums, or repeated messages.
                 * 
                 * Because this is an option, the above two restrictions are not enforced by
                 * the protocol compiler.
                 */
                messageSetWireFormat?: (boolean | null);
                /**
                 * Disables the generation of the standard "descriptor()" accessor, which can
                 * conflict with a field of the same name.  This is meant to make migration
                 * from proto1 easier; new code should avoid fields named "descriptor".
                 */
                noStandardDescriptorAccessor?: (boolean | null);
                /**
                 * Is this message deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for the message, or it will be completely ignored; in the very least,
                 * this is a formalization for deprecating messages.
                 */
                deprecated?: (boolean | null);
                /**
                 * Whether the message is an automatically generated map entry type for the
                 * maps field.
                 * 
                 * For maps fields:
                 * map<KeyType, ValueType> map_field = 1;
                 * The parsed descriptor looks like:
                 * message MapFieldEntry {
                 * option map_entry = true;
                 * optional KeyType key = 1;
                 * optional ValueType value = 2;
                 * }
                 * repeated MapFieldEntry map_field = 1;
                 * 
                 * Implementations may choose not to generate the map_entry=true message, but
                 * use a native map in the target language to hold the keys and values.
                 * The reflection APIs in such implementations still need to work as
                 * if the field is a repeated message field.
                 * 
                 * NOTE: Do not set the option in .proto files. Always use the maps syntax
                 * instead. The option should only be implicitly set by the proto compiler
                 * parser.
                 */
                mapEntry?: (boolean | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.decompositeOf'?: (string | null);
                '.wix.api.decompositionMinimumFields'?: ($wrapper.wix.api.FieldSet[] | null);
                '.wix.api.unwrapArrayValue'?: (boolean | null);
                '.wix.api.messageDeprecated'?: ($wrapper.wix.api.Deprecated | null);
                '.wix.api.unique'?: ($wrapper.wix.api.Unique[] | null);
            }
            export interface FieldOptions {
                /**
                 * The ctype option instructs the C++ code generator to use a different
                 * representation of the field than it normally would.  See the specific
                 * options below.  This option is not yet implemented in the open source
                 * release -- sorry, we'll try to include it in a future version!
                 */
                ctype?: ($wrapper.google.protobuf.FieldOptions.CType | null);
                /**
                 * The packed option can be enabled for repeated primitive fields to enable
                 * a more efficient representation on the wire. Rather than repeatedly
                 * writing the tag and type for each element, the entire array is encoded as
                 * a single length-delimited blob. In proto3, only explicit setting it to
                 * false will avoid using packed encoding.
                 */
                packed?: (boolean | null);
                /**
                 * The jstype option determines the JavaScript type used for values of the
                 * field.  The option is permitted only for 64 bit integral and fixed types
                 * (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
                 * is represented as JavaScript string, which avoids loss of precision that
                 * can happen when a large value is converted to a floating point JavaScript.
                 * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
                 * use the JavaScript "number" type.  The behavior of the default option
                 * JS_NORMAL is implementation dependent.
                 * 
                 * This option is an enum to permit additional types to be added, e.g.
                 * goog.math.Integer.
                 */
                jstype?: ($wrapper.google.protobuf.FieldOptions.JSType | null);
                /**
                 * Should this field be parsed lazily?  Lazy applies only to message-type
                 * fields.  It means that when the outer message is initially parsed, the
                 * inner message's contents will not be parsed but instead stored in encoded
                 * form.  The inner message will actually be parsed when it is first accessed.
                 * 
                 * This is only a hint.  Implementations are free to choose whether to use
                 * eager or lazy parsing regardless of the value of this option.  However,
                 * setting this option true suggests that the protocol author believes that
                 * using lazy parsing on this field is worth the additional bookkeeping
                 * overhead typically needed to implement it.
                 * 
                 * This option does not affect the public interface of any generated code;
                 * all method signatures remain the same.  Furthermore, thread-safety of the
                 * interface is not affected by this option; const methods remain safe to
                 * call from multiple threads concurrently, while non-const methods continue
                 * to require exclusive access.
                 * 
                 * 
                 * Note that implementations may choose not to check required fields within
                 * a lazy sub-message.  That is, calling IsInitialized() on the outer message
                 * may return true even if the inner message has missing required fields.
                 * This is necessary because otherwise the inner message would have to be
                 * parsed in order to perform the check, defeating the purpose of lazy
                 * parsing.  An implementation which chooses not to check required fields
                 * must be consistent about it.  That is, for any particular sub-message, the
                 * implementation must either *always* check its required fields, or *never*
                 * check its required fields, regardless of whether or not the message has
                 * been parsed.
                 */
                lazy?: (boolean | null);
                /**
                 * Is this field deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for accessors, or it will be completely ignored; in the very least, this
                 * is a formalization for deprecating fields.
                 */
                deprecated?: (boolean | null);
                /**
                 * For Google-internal migration only. Do not use.
                 */
                weak?: (boolean | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.fieldExposure'?: ($wrapper.wix.api.Exposure | null);
                '.wix.api.fieldMaturity'?: ($wrapper.wix.api.Maturity | null);
                '.wix.api.pii'?: (boolean | null);
                '.wix.api.referencedEntity'?: (string | null);
                '.wix.api.referencedEntityField'?: ($wrapper.wix.api.ReferenceEntityField | null);
                '.wix.api.fieldDeprecated'?: ($wrapper.wix.api.Deprecated | null);
                '.wix.api.translatable'?: ($wrapper.wix.api.Translatable | null);
                '.wix.api.sampleData'?: (string | null);
                '.wix.api.conditional'?: ($wrapper.wix.api.Conditional | null);
                '.wix.api.nullable'?: (boolean | null);
                '.wix.api.max'?: (number | null);
                '.wix.api.min'?: (number | null);
                '.wix.api.maxLength'?: (number | null);
                '.wix.api.minLength'?: (number | null);
                '.wix.api.exactLength'?: (number | null);
                '.wix.api.maxSize'?: (number | null);
                '.wix.api.minSize'?: (number | null);
                '.wix.api.exactSize'?: (number | null);
                '.wix.api.format'?: ($wrapper.wix.api.Format | null);
                '.wix.api.readOnly'?: (boolean | null);
                '.wix.api.immutable'?: (boolean | null);
                '.wix.api.writeOnly'?: (boolean | null);
                '.wix.api.decimalValue'?: ($wrapper.wix.api.DecimalValueOptions | null);
                '.wix.api.customValidation'?: ($wrapper.wix.api.CustomValidationError | null);
            }
            export namespace FieldOptions {
                export enum CType {
                    STRING = "STRING",
                    CORD = "CORD",
                    STRING_PIECE = "STRING_PIECE",
                }
                export enum JSType {
                    JS_NORMAL = "JS_NORMAL",
                    JS_STRING = "JS_STRING",
                    JS_NUMBER = "JS_NUMBER",
                }
            }
            export interface OneofOptions {
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.alignedWithEnum'?: ($wrapper.wix.api.AlignedWithEnum | null);
            }
            export interface EnumOptions {
                /**
                 * Set this option to true to allow mapping different tag names to the same
                 * value.
                 */
                allowAlias?: (boolean | null);
                /**
                 * Is this enum deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for the enum, or it will be completely ignored; in the very least, this
                 * is a formalization for deprecating enums.
                 */
                deprecated?: (boolean | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
            }
            export interface EnumValueOptions {
                /**
                 * Is this enum value deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for the enum value, or it will be completely ignored; in the very least,
                 * this is a formalization for deprecating enum values.
                 */
                deprecated?: (boolean | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.enumMaturity'?: ($wrapper.wix.api.Maturity | null);
                '.wix.api.enumExposure'?: ($wrapper.wix.api.Exposure | null);
            }
            export interface ServiceOptions {
                /**
                 * Is this service deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for the service, or it will be completely ignored; in the very least,
                 * this is a formalization for deprecating services.
                 */
                deprecated?: (boolean | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.serviceMaturity'?: ($wrapper.wix.api.Maturity | null);
                '.wix.api.serviceExposure'?: ($wrapper.wix.api.Exposure | null);
                '.wix.api.serviceTenancy'?: ($wrapper.wix.api.TenancyOptions | null);
                '.wix.api.serviceDeprecated'?: ($wrapper.wix.api.Deprecated | null);
                '.wix.api.appendixFiles'?: ($wrapper.wix.api.ServiceAppendix[] | null);
                '.wix.api.errorDef'?: ($wrapper.wix.api.Error[] | null);
            }
            export interface MethodOptions {
                /**
                 * Is this method deprecated?
                 * Depending on the target platform, this can emit Deprecated annotations
                 * for the method, or it will be completely ignored; in the very least,
                 * this is a formalization for deprecating methods.
                 */
                deprecated?: (boolean | null);
                idempotencyLevel?: ($wrapper.google.protobuf.MethodOptions.IdempotencyLevel | null);
                /**
                 * The parser stores options it doesn't recognize here. See above.
                 */
                uninterpretedOption?: ($wrapper.google.protobuf.UninterpretedOption[] | null);
                '.wix.api.exposure'?: ($wrapper.wix.api.Exposure | null);
                '.wix.api.maturity'?: ($wrapper.wix.api.Maturity | null);
                '.wix.api.cacheable'?: ($wrapper.wix.api.CacheSettings | null);
                '.wix.api.deprecated'?: ($wrapper.wix.api.Deprecated | null);
                '.wix.api.crud'?: ($wrapper.wix.api.Crud | null);
                '.wix.api.acceptsLinguist'?: (boolean | null);
                '.wix.api.audience'?: ($wrapper.wix.api.Audience | null);
                '.wix.api.tenancy'?: ($wrapper.wix.api.TenancyOptions | null);
                '.wix.api.required'?: (string[] | null);
                '.wix.api.writable'?: (string[] | null);
                '.wix.api.error'?: ($wrapper.wix.api.Error[] | null);
                '.wix.api.customValidationError'?: ($wrapper.wix.api.CustomValidationError[] | null);
                '.wix.api.inheritCrudErrors'?: ($wrapper.wix.api.InheritCrudErrors[] | null);
                '.wix.api.errorRef'?: ($wrapper.wix.api.ErrorRef[] | null);
            }
            export namespace MethodOptions {
                /**
                 * Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
                 * or neither? HTTP based RPC implementation may choose GET verb for safe
                 * methods, and PUT verb for idempotent methods instead of the default POST.
                 */
                export enum IdempotencyLevel {
                    IDEMPOTENCY_UNKNOWN = "IDEMPOTENCY_UNKNOWN",
                    NO_SIDE_EFFECTS = "NO_SIDE_EFFECTS",
                    IDEMPOTENT = "IDEMPOTENT",
                }
            }
            /**
             * A message representing a option the parser does not recognize. This only
             * appears in options protos created by the compiler::Parser class.
             * DescriptorPool resolves these when building Descriptor objects. Therefore,
             * options protos in descriptor objects (e.g. returned by Descriptor::options(),
             * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
             * in them.
             */
            export interface UninterpretedOption {
                name?: ($wrapper.google.protobuf.UninterpretedOption.NamePart[] | null);
                /**
                 * The value of the uninterpreted option, in whatever type the tokenizer
                 * identified it as during parsing. Exactly one of these should be set.
                 */
                identifierValue?: (string | null);
                positiveIntValue?: ((number | string) | null);
                negativeIntValue?: ((number | string) | null);
                doubleValue?: (number | null);
                stringValue?: (Uint8Array | null);
                aggregateValue?: (string | null);
            }
            export namespace UninterpretedOption {
                /**
                 * The name of the uninterpreted option.  Each string represents a segment in
                 * a dot-separated name.  is_extension is true iff a segment represents an
                 * extension (denoted with parentheses in options specs in .proto files).
                 * E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
                 * "foo.(bar.baz).qux".
                 */
                export interface NamePart {
                    namePart?: (string | null);
                    isExtension?: (boolean | null);
                }
            }
            /**
             * Encapsulates information about the original source file from which a
             * FileDescriptorProto was generated.
             */
            export interface SourceCodeInfo {
                /**
                 * A Location identifies a piece of source code in a .proto file which
                 * corresponds to a particular definition.  This information is intended
                 * to be useful to IDEs, code indexers, documentation generators, and similar
                 * tools.
                 * 
                 * For example, say we have a file like:
                 * message Foo {
                 * optional string foo = 1;
                 * }
                 * Let's look at just the field definition:
                 * optional string foo = 1;
                 * ^       ^^     ^^  ^  ^^^
                 * a       bc     de  f  ghi
                 * We have the following locations:
                 * span   path               represents
                 * [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
                 * [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
                 * [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
                 * [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
                 * [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
                 * 
                 * Notes:
                 * - A location may refer to a repeated field itself (i.e. not to any
                 * particular index within it).  This is used whenever a set of elements are
                 * logically enclosed in a single code segment.  For example, an entire
                 * extend block (possibly containing multiple extension definitions) will
                 * have an outer location whose path refers to the "extensions" repeated
                 * field without an index.
                 * - Multiple locations may have the same path.  This happens when a single
                 * logical declaration is spread out across multiple places.  The most
                 * obvious example is the "extend" block again -- there may be multiple
                 * extend blocks in the same scope, each of which will have the same path.
                 * - A location's span is not always a subset of its parent's span.  For
                 * example, the "extendee" of an extension declaration appears at the
                 * beginning of the "extend" block and is shared by all extensions within
                 * the block.
                 * - Just because a location's span is a subset of some other location's span
                 * does not mean that it is a descendant.  For example, a "group" defines
                 * both a type and a field in a single declaration.  Thus, the locations
                 * corresponding to the type and field and their components will overlap.
                 * - Code which tries to interpret locations should probably be designed to
                 * ignore those that it doesn't understand, as more types of locations could
                 * be recorded in the future.
                 */
                location?: ($wrapper.google.protobuf.SourceCodeInfo.Location[] | null);
            }
            export namespace SourceCodeInfo {
                export interface Location {
                    /**
                     * Identifies which part of the FileDescriptorProto was defined at this
                     * location.
                     * 
                     * Each element is a field number or an index.  They form a path from
                     * the root FileDescriptorProto to the place where the definition.  For
                     * example, this path:
                     * [ 4, 3, 2, 7, 1 ]
                     * refers to:
                     * file.message_type(3)  // 4, 3
                     * .field(7)         // 2, 7
                     * .name()           // 1
                     * This is because FileDescriptorProto.message_type has field number 4:
                     * repeated DescriptorProto message_type = 4;
                     * and DescriptorProto.field has field number 2:
                     * repeated FieldDescriptorProto field = 2;
                     * and FieldDescriptorProto.name has field number 1:
                     * optional string name = 1;
                     * 
                     * Thus, the above path gives the location of a field name.  If we removed
                     * the last element:
                     * [ 4, 3, 2, 7 ]
                     * this path refers to the whole field declaration (from the beginning
                     * of the label to the terminating semicolon).
                     */
                    path?: (number[] | null);
                    /**
                     * Always has exactly three or four elements: start line, start column,
                     * end line (optional, otherwise assumed same as start line), end column.
                     * These are packed into a single field for efficiency.  Note that line
                     * and column numbers are zero-based -- typically you will want to add
                     * 1 to each before displaying to a user.
                     */
                    span?: (number[] | null);
                    /**
                     * If this SourceCodeInfo represents a complete declaration, these are any
                     * comments appearing before and after the declaration which appear to be
                     * attached to the declaration.
                     * 
                     * A series of line comments appearing on consecutive lines, with no other
                     * tokens appearing on those lines, will be treated as a single comment.
                     * 
                     * leading_detached_comments will keep paragraphs of comments that appear
                     * before (but not connected to) the current element. Each paragraph,
                     * separated by empty lines, will be one comment element in the repeated
                     * field.
                     * 
                     * Only the comment content is provided; comment markers (e.g. //) are
                     * stripped out.  For block comments, leading whitespace and an asterisk
                     * will be stripped from the beginning of each line other than the first.
                     * Newlines are included in the output.
                     * 
                     * Examples:
                     * 
                     * optional int32 foo = 1;  // Comment attached to foo.
                     * // Comment attached to bar.
                     * optional int32 bar = 2;
                     * 
                     * optional string baz = 3;
                     * // Comment attached to baz.
                     * // Another line attached to baz.
                     * 
                     * // Comment attached to qux.
                     * //
                     * // Another line attached to qux.
                     * optional double qux = 4;
                     * 
                     * // Detached comment for corge. This is not leading or trailing comments
                     * // to qux or corge because there are blank lines separating it from
                     * // both.
                     * 
                     * // Detached comment for corge paragraph 2.
                     * 
                     * optional string corge = 5;
                     * /* Block comment attached
                     * * to corge.  Leading asterisks
                     * * will be removed. * /
                     * /* Block comment attached to
                     * * grault. * /
                     * optional int32 grault = 6;
                     * 
                     * // ignored detached comments.
                     */
                    leadingComments?: (string | null);
                    trailingComments?: (string | null);
                    leadingDetachedComments?: (string[] | null);
                }
            }
            /**
             * Describes the relationship between generated code and its original source
             * file. A GeneratedCodeInfo message is associated with only one generated
             * source file, but may contain references to different source .proto files.
             */
            export interface GeneratedCodeInfo {
                /**
                 * An Annotation connects some span of text in generated code to an element
                 * of its generating .proto file.
                 */
                annotation?: ($wrapper.google.protobuf.GeneratedCodeInfo.Annotation[] | null);
            }
            export namespace GeneratedCodeInfo {
                export interface Annotation {
                    /**
                     * Identifies the element in the original source .proto file. This field
                     * is formatted the same as SourceCodeInfo.Location.path.
                     */
                    path?: (number[] | null);
                    /**
                     * Identifies the filesystem path to the original source .proto.
                     */
                    sourceFile?: (string | null);
                    /**
                     * Identifies the starting offset in bytes in the generated code
                     * that relates to the identified object.
                     */
                    begin?: (number | null);
                    /**
                     * Identifies the ending offset in bytes in the generated code that
                     * relates to the identified offset. The end offset should be one past
                     * the last relevant byte (so the length of the text = end - begin).
                     */
                    end?: (number | null);
                }
            }
        }
    }
}

export default $wrapper;