puppet-editor-services 2.0.4

data/lib/lsp/lsp_protocol_progress.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY. This file is built automatically
+# LSP Protocol: vscode-languageserver-protocol/lib/protocol.progress.d.ts
+
+module LSP
+  # export interface WorkDoneProgressClientCapabilities {
+  #     /**
+  #      * Window specific client capabilities.
+  #      */
+  #     window?: {
+  #         /**
+  #          * Whether client supports handling progress notifications. If set servers are allowed to
+  #          * report in `workDoneProgress` property in the request specific server capabilities.
+  #          *
+  #          * Since 3.15.0
+  #          */
+  #         workDoneProgress?: boolean;
+  #     };
+  # }
+  class WorkDoneProgressClientCapabilities < LSPBase
+    attr_accessor :window # type: {
+
+    #        /**
+    #         * Whether client supports handling progress notifications. If set servers are allowed to
+    #         * report in `workDoneProgress` property in the request specific server capabilities.
+    #         *
+    #         * Since 3.15.0
+    #         */
+    #        workDoneProgress?: boolean;
+    #    }
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[window]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.window = value['window'] # Unknown type
+      self
+    end
+  end
+
+  # export interface WorkDoneProgressBegin {
+  #     kind: 'begin';
+  #     /**
+  #      * Mandatory title of the progress operation. Used to briefly inform about
+  #      * the kind of operation being performed.
+  #      *
+  #      * Examples: "Indexing" or "Linking dependencies".
+  #      */
+  #     title: string;
+  #     /**
+  #      * Controls if a cancel button should show to allow the user to cancel the
+  #      * long running operation. Clients that don't support cancellation are allowed
+  #      * to ignore the setting.
+  #      */
+  #     cancellable?: boolean;
+  #     /**
+  #      * Optional, more detailed associated progress message. Contains
+  #      * complementary information to the `title`.
+  #      *
+  #      * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+  #      * If unset, the previous progress message (if any) is still valid.
+  #      */
+  #     message?: string;
+  #     /**
+  #      * Optional progress percentage to display (value 100 is considered 100%).
+  #      * If not provided infinite progress is assumed and clients are allowed
+  #      * to ignore the `percentage` value in subsequent in report notifications.
+  #      *
+  #      * The value should be steadily rising. Clients are free to ignore values
+  #      * that are not following this rule.
+  #      */
+  #     percentage?: number;
+  # }
+  class WorkDoneProgressBegin < LSPBase
+    attr_accessor :kind, :title, :cancellable, :message, :percentage # type: string with value 'begin' # type: string # type: boolean # type: string # type: number
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[cancellable message percentage]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.kind = value['kind'] # Unknown type
+      self.title = value['title']
+      self.cancellable = value['cancellable'] # Unknown type
+      self.message = value['message']
+      self.percentage = value['percentage']
+      self
+    end
+  end
+
+  # export interface WorkDoneProgressReport {
+  #     kind: 'report';
+  #     /**
+  #      * Controls enablement state of a cancel button. This property is only valid if a cancel
+  #      * button got requested in the `WorkDoneProgressStart` payload.
+  #      *
+  #      * Clients that don't support cancellation or don't support control the button's
+  #      * enablement state are allowed to ignore the setting.
+  #      */
+  #     cancellable?: boolean;
+  #     /**
+  #      * Optional, more detailed associated progress message. Contains
+  #      * complementary information to the `title`.
+  #      *
+  #      * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
+  #      * If unset, the previous progress message (if any) is still valid.
+  #      */
+  #     message?: string;
+  #     /**
+  #      * Optional progress percentage to display (value 100 is considered 100%).
+  #      * If not provided infinite progress is assumed and clients are allowed
+  #      * to ignore the `percentage` value in subsequent in report notifications.
+  #      *
+  #      * The value should be steadily rising. Clients are free to ignore values
+  #      * that are not following this rule.
+  #      */
+  #     percentage?: number;
+  # }
+  class WorkDoneProgressReport < LSPBase
+    attr_accessor :kind, :cancellable, :message, :percentage # type: string with value 'report' # type: boolean # type: string # type: number
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[cancellable message percentage]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.kind = value['kind'] # Unknown type
+      self.cancellable = value['cancellable'] # Unknown type
+      self.message = value['message']
+      self.percentage = value['percentage']
+      self
+    end
+  end
+
+  # export interface WorkDoneProgressEnd {
+  #     kind: 'end';
+  #     /**
+  #      * Optional, a final message indicating to for example indicate the outcome
+  #      * of the operation.
+  #      */
+  #     message?: string;
+  # }
+  class WorkDoneProgressEnd < LSPBase
+    attr_accessor :kind, :message # type: string with value 'end' # type: string
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[message]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.kind = value['kind'] # Unknown type
+      self.message = value['message']
+      self
+    end
+  end
+
+  # export interface WorkDoneProgressCreateParams {
+  #     /**
+  #      * The token to be used to report progress.
+  #      */
+  #     token: ProgressToken;
+  # }
+  class WorkDoneProgressCreateParams < LSPBase
+    attr_accessor :token # type: ProgressToken
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.token = value['token'] # Unknown type
+      self
+    end
+  end
+
+  # export interface WorkDoneProgressCancelParams {
+  #     /**
+  #      * The token to be used to report progress.
+  #      */
+  #     token: ProgressToken;
+  # }
+  class WorkDoneProgressCancelParams < LSPBase
+    attr_accessor :token # type: ProgressToken
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.token = value['token'] # Unknown type
+      self
+    end
+  end
+end
+
+# rubocop:enable Style/AsciiComments

data/lib/lsp/lsp_protocol_selectionrange.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY. This file is built automatically
+# LSP Protocol: vscode-languageserver-protocol/lib/protocol.selectionRange.d.ts
+
+# rubocop:disable Layout/EmptyLinesAroundClassBody
+# rubocop:disable Lint/UselessAssignment
+# rubocop:disable Naming/MethodName
+
+module LSP
+  # export interface SelectionRangeClientCapabilities {
+  #     /**
+  #      * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+  #      * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+  #      * capability as well.
+  #      */
+  #     dynamicRegistration?: boolean;
+  # }
+  class SelectionRangeClientCapabilities < LSPBase
+    attr_accessor :dynamicRegistration # type: boolean
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[dynamicRegistration]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.dynamicRegistration = value['dynamicRegistration'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SelectionRangeOptions extends WorkDoneProgressOptions {
+  # }
+  class SelectionRangeOptions < LSPBase
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self
+    end
+  end
+
+  # export interface SelectionRangeRegistrationOptions extends SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions {
+  # }
+  class SelectionRangeRegistrationOptions < LSPBase
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self
+    end
+  end
+
+  # export interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultParams {
+  #     /**
+  #      * The text document.
+  #      */
+  #     textDocument: TextDocumentIdentifier;
+  #     /**
+  #      * The positions inside the text document.
+  #      */
+  #     positions: Position[];
+  # }
+  class SelectionRangeParams < LSPBase
+    attr_accessor :textDocument, :positions # type: TextDocumentIdentifier # type: Position[]
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.textDocument = value['textDocument'] # Unknown type
+      self.positions = value['positions'].map { |val| val } unless value['positions'].nil? # Unknown array type
+      self
+    end
+  end
+end
+
+# rubocop:enable Layout/EmptyLinesAroundClassBody
+# rubocop:enable Lint/UselessAssignment
+# rubocop:enable Style/AsciiComments
+# rubocop:enable Naming/MethodName

data/lib/lsp/lsp_protocol_sematictokens.proposed.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY. This file is built automatically
+# LSP Protocol: vscode-languageserver-protocol/lib/protocol.sematicTokens.proposed.d.ts
+
+# rubocop:disable Naming/MethodName
+
+module LSP
+  # export interface SemanticTokensLegend {
+  #     /**
+  #      * The token types a server uses.
+  #      */
+  #     tokenTypes: string[];
+  #     /**
+  #      * The token modifiers a server uses.
+  #      */
+  #     tokenModifiers: string[];
+  # }
+  class SemanticTokensLegend < LSPBase
+    attr_accessor :tokenTypes, :tokenModifiers # type: string[] # type: string[]
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.tokenTypes = value['tokenTypes'].map { |val| val } unless value['tokenTypes'].nil?
+      self.tokenModifiers = value['tokenModifiers'].map { |val| val } unless value['tokenModifiers'].nil?
+      self
+    end
+  end
+
+  # export interface SemanticTokens {
+  #     /**
+  #      * An optional result id. If provided and clients support delta updating
+  #      * the client will include the result id in the next semantic token request.
+  #      * A server can then instead of computing all sematic tokens again simply
+  #      * send a delta.
+  #      */
+  #     resultId?: string;
+  #     /**
+  #      * The actual tokens. For a detailed description about how the data is
+  #      * structured pls see
+  #      * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71
+  #      */
+  #     data: number[];
+  # }
+  class SemanticTokens < LSPBase
+    attr_accessor :resultId, :data # type: string # type: number[]
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[resultId]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.resultId = value['resultId']
+      self.data = value['data'].map { |val| val } unless value['data'].nil?
+      self
+    end
+  end
+
+  # export interface SemanticTokensPartialResult {
+  #     data: number[];
+  # }
+  class SemanticTokensPartialResult < LSPBase
+    attr_accessor :data # type: number[]
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.data = value['data'].map { |val| val } unless value['data'].nil?
+      self
+    end
+  end
+
+  # export interface SemanticTokensEdit {
+  #     start: number;
+  #     deleteCount: number;
+  #     data?: number[];
+  # }
+  class SemanticTokensEdit < LSPBase
+    attr_accessor :start, :deleteCount, :data # type: number # type: number # type: number[]
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[data]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.start = value['start']
+      self.deleteCount = value['deleteCount']
+      self.data = value['data'].map { |val| val } unless value['data'].nil?
+      self
+    end
+  end
+
+  # export interface SemanticTokensEdits {
+  #     readonly resultId?: string;
+  #     /**
+  #      * For a detailed description how these edits are structured pls see
+  #      * https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L131
+  #      */
+  #     edits: SemanticTokensEdit[];
+  # }
+  class SemanticTokensEdits < LSPBase
+    attr_accessor :resultId, :edits # type: string # type: SemanticTokensEdit[]
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[resultId]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.resultId = value['resultId']
+      self.edits = to_typed_aray(value['edits'], SemanticTokensEdit)
+      self
+    end
+  end
+
+  # export interface SemanticTokensEditsPartialResult {
+  #     edits: SemanticTokensEdit[];
+  # }
+  class SemanticTokensEditsPartialResult < LSPBase
+    attr_accessor :edits # type: SemanticTokensEdit[]
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.edits = to_typed_aray(value['edits'], SemanticTokensEdit)
+      self
+    end
+  end
+
+  # export interface SemanticTokensClientCapabilities {
+  #     /**
+  #      * The text document client capabilities
+  #      */
+  #     textDocument?: {
+  #         /**
+  #          * Capabilities specific to the `textDocument/semanticTokens`
+  #          *
+  #          * @since 3.16.0 - Proposed state
+  #          */
+  #         semanticTokens?: {
+  #             /**
+  #              * Whether implementation supports dynamic registration. If this is set to `true`
+  #              * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+  #              * return value for the corresponding server capability as well.
+  #              */
+  #             dynamicRegistration?: boolean;
+  #             /**
+  #              * The token types know by the client.
+  #              */
+  #             tokenTypes: string[];
+  #             /**
+  #              * The token modifiers know by the client.
+  #              */
+  #             tokenModifiers: string[];
+  #         };
+  #     };
+  # }
+  class SemanticTokensClientCapabilities < LSPBase
+    attr_accessor :textDocument # type: {
+
+    #        /**
+    #         * Capabilities specific to the `textDocument/semanticTokens`
+    #         *
+    #         * @since 3.16.0 - Proposed state
+    #         */
+    #        semanticTokens?: {
+    #            /**
+    #             * Whether implementation supports dynamic registration. If this is set to `true`
+    #             * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+    #             * return value for the corresponding server capability as well.
+    #             */
+    #            dynamicRegistration?: boolean;
+    #            /**
+    #             * The token types know by the client.
+    #             */
+    #            tokenTypes: string[];
+    #            /**
+    #             * The token modifiers know by the client.
+    #             */
+    #            tokenModifiers: string[];
+    #        };
+    #    }
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[textDocument]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.textDocument = value['textDocument'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SemanticTokensOptions extends WorkDoneProgressOptions {
+  #     /**
+  #      * The legend used by the server
+  #      */
+  #     legend: SemanticTokensLegend;
+  #     /**
+  #      * Server supports providing semantic tokens for a sepcific range
+  #      * of a document.
+  #      */
+  #     rangeProvider?: boolean;
+  #     /**
+  #      * Server supports providing semantic tokens for a full document.
+  #      */
+  #     documentProvider?: boolean | {
+  #         /**
+  #          * The server supports deltas for full documents.
+  #          */
+  #         edits?: boolean;
+  #     };
+  # }
+  class SemanticTokensOptions < LSPBase
+    attr_accessor :legend, :rangeProvider, :documentProvider # type: SemanticTokensLegend # type: boolean # type: boolean | {
+
+    #        /**
+    #         * The server supports deltas for full documents.
+    #         */
+    #        edits?: boolean;
+    #    }
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[rangeProvider documentProvider]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.legend = SemanticTokensLegend.new(value['legend']) unless value['legend'].nil?
+      self.rangeProvider = value['rangeProvider'] # Unknown type
+      self.documentProvider = value['documentProvider'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions {
+  # }
+  class SemanticTokensRegistrationOptions < LSPBase
+    attr_accessor :legend, :rangeProvider, :documentProvider # type: SemanticTokensLegend # type: boolean # type: boolean | {
+
+    #        /**
+    #         * The server supports deltas for full documents.
+    #         */
+    #        edits?: boolean;
+    #    }
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[rangeProvider documentProvider]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.legend = SemanticTokensLegend.new(value['legend']) unless value['legend'].nil?
+      self.rangeProvider = value['rangeProvider'] # Unknown type
+      self.documentProvider = value['documentProvider'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SemanticTokensServerCapabilities {
+  #     semanticTokensProvider: SemanticTokensOptions | SemanticTokensRegistrationOptions;
+  # }
+  class SemanticTokensServerCapabilities < LSPBase
+    attr_accessor :semanticTokensProvider # type: SemanticTokensOptions | SemanticTokensRegistrationOptions
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.semanticTokensProvider = value['semanticTokensProvider'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams {
+  #     /**
+  #      * The text document.
+  #      */
+  #     textDocument: TextDocumentIdentifier;
+  # }
+  class SemanticTokensParams < LSPBase
+    attr_accessor :textDocument # type: TextDocumentIdentifier
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.textDocument = value['textDocument'] # Unknown type
+      self
+    end
+  end
+
+  # export interface SemanticTokensEditsParams extends WorkDoneProgressParams, PartialResultParams {
+  #     /**
+  #      * The text document.
+  #      */
+  #     textDocument: TextDocumentIdentifier;
+  #     /**
+  #      * The previous result id.
+  #      */
+  #     previousResultId: string;
+  # }
+  class SemanticTokensEditsParams < LSPBase
+    attr_accessor :textDocument, :previousResultId # type: TextDocumentIdentifier # type: string
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.textDocument = value['textDocument'] # Unknown type
+      self.previousResultId = value['previousResultId']
+      self
+    end
+  end
+
+  # export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams {
+  #     /**
+  #      * The text document.
+  #      */
+  #     textDocument: TextDocumentIdentifier;
+  #     /**
+  #      * The range the semantic tokens are requested for.
+  #      */
+  #     range: Range;
+  # }
+  class SemanticTokensRangeParams < LSPBase
+    attr_accessor :textDocument, :range # type: TextDocumentIdentifier # type: Range
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.textDocument = value['textDocument'] # Unknown type
+      self.range = value['range'] # Unknown type
+      self
+    end
+  end
+end
+
+# rubocop:enable Style/AsciiComments
+# rubocop:enable Naming/MethodName

data/lib/lsp/lsp_protocol_typedefinition.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY. This file is built automatically
+# LSP Protocol: vscode-languageserver-protocol/lib/protocol.typeDefinition.d.ts
+
+# rubocop:disable Layout/EmptyLinesAroundClassBody
+# rubocop:disable Lint/UselessAssignment
+# rubocop:disable Naming/MethodName
+
+module LSP
+  # export interface TypeDefinitionClientCapabilities {
+  #     /**
+  #      * Whether implementation supports dynamic registration. If this is set to `true`
+  #      * the client supports the new `TypeDefinitionRegistrationOptions` return value
+  #      * for the corresponding server capability as well.
+  #      */
+  #     dynamicRegistration?: boolean;
+  #     /**
+  #      * The client supports additional metadata in the form of definition links.
+  #      *
+  #      * Since 3.14.0
+  #      */
+  #     linkSupport?: boolean;
+  # }
+  class TypeDefinitionClientCapabilities < LSPBase
+    attr_accessor :dynamicRegistration, :linkSupport # type: boolean # type: boolean
+
+    def initialize(initial_hash = nil)
+      super
+      @optional_method_names = %i[dynamicRegistration linkSupport]
+    end
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self.dynamicRegistration = value['dynamicRegistration'] # Unknown type
+      self.linkSupport = value['linkSupport'] # Unknown type
+      self
+    end
+  end
+
+  # export interface TypeDefinitionOptions extends WorkDoneProgressOptions {
+  # }
+  class TypeDefinitionOptions < LSPBase
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self
+    end
+  end
+
+  # export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions {
+  # }
+  class TypeDefinitionRegistrationOptions < LSPBase
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self
+    end
+  end
+
+  # export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams {
+  # }
+  class TypeDefinitionParams < LSPBase
+
+    def from_h!(value)
+      value = {} if value.nil?
+      self
+    end
+  end
+end
+
+# rubocop:enable Layout/EmptyLinesAroundClassBody
+# rubocop:enable Lint/UselessAssignment
+# rubocop:enable Style/AsciiComments
+# rubocop:enable Naming/MethodName