octoprint 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (122) hide show
  1. checksums.yaml +7 -0
  2. data/CHANGELOG.md +10 -0
  3. data/LICENSE.txt +21 -0
  4. data/README.md +336 -0
  5. data/lib/octoprint/access/group.rb +88 -0
  6. data/lib/octoprint/access/groups.rb +166 -0
  7. data/lib/octoprint/access/login_response.rb +63 -0
  8. data/lib/octoprint/access/permission.rb +71 -0
  9. data/lib/octoprint/access/permissions.rb +29 -0
  10. data/lib/octoprint/access/user.rb +95 -0
  11. data/lib/octoprint/access/users.rb +347 -0
  12. data/lib/octoprint/auto_initializable.rb +219 -0
  13. data/lib/octoprint/base_resource.rb +139 -0
  14. data/lib/octoprint/client.rb +151 -0
  15. data/lib/octoprint/connection/options.rb +44 -0
  16. data/lib/octoprint/connection/settings.rb +35 -0
  17. data/lib/octoprint/connection.rb +74 -0
  18. data/lib/octoprint/deserializable.rb +483 -0
  19. data/lib/octoprint/exceptions.rb +30 -0
  20. data/lib/octoprint/files/file.rb +55 -0
  21. data/lib/octoprint/files/folder.rb +29 -0
  22. data/lib/octoprint/files/operation_result.rb +37 -0
  23. data/lib/octoprint/files/refs.rb +19 -0
  24. data/lib/octoprint/files.rb +238 -0
  25. data/lib/octoprint/job/information.rb +42 -0
  26. data/lib/octoprint/job/progress.rb +46 -0
  27. data/lib/octoprint/job.rb +140 -0
  28. data/lib/octoprint/languages/language_pack.rb +31 -0
  29. data/lib/octoprint/languages.rb +102 -0
  30. data/lib/octoprint/location.rb +23 -0
  31. data/lib/octoprint/logs/log_file.rb +59 -0
  32. data/lib/octoprint/logs/references.rb +28 -0
  33. data/lib/octoprint/logs.rb +98 -0
  34. data/lib/octoprint/printer/bed.rb +32 -0
  35. data/lib/octoprint/printer/chamber.rb +29 -0
  36. data/lib/octoprint/printer/command.rb +129 -0
  37. data/lib/octoprint/printer/custom_control/input.rb +45 -0
  38. data/lib/octoprint/printer/custom_control.rb +119 -0
  39. data/lib/octoprint/printer/error_information.rb +104 -0
  40. data/lib/octoprint/printer/heater.rb +113 -0
  41. data/lib/octoprint/printer/history_query.rb +25 -0
  42. data/lib/octoprint/printer/printhead.rb +105 -0
  43. data/lib/octoprint/printer/sd.rb +97 -0
  44. data/lib/octoprint/printer/state.rb +41 -0
  45. data/lib/octoprint/printer/state_flags.rb +70 -0
  46. data/lib/octoprint/printer/temperature_attributes.rb +70 -0
  47. data/lib/octoprint/printer/temperature_data.rb +53 -0
  48. data/lib/octoprint/printer/temperature_data_point.rb +73 -0
  49. data/lib/octoprint/printer/temperature_reading.rb +47 -0
  50. data/lib/octoprint/printer/temperature_state.rb +67 -0
  51. data/lib/octoprint/printer/tool.rb +154 -0
  52. data/lib/octoprint/printer.rb +126 -0
  53. data/lib/octoprint/printer_profiles/printer_profile.rb +40 -0
  54. data/lib/octoprint/printer_profiles.rb +158 -0
  55. data/lib/octoprint/server_information.rb +51 -0
  56. data/lib/octoprint/server_version.rb +52 -0
  57. data/lib/octoprint/settings/webcam.rb +135 -0
  58. data/lib/octoprint/settings.rb +133 -0
  59. data/lib/octoprint/slicing/profile.rb +65 -0
  60. data/lib/octoprint/slicing/slicer.rb +83 -0
  61. data/lib/octoprint/slicing.rb +227 -0
  62. data/lib/octoprint/system_commands/command.rb +41 -0
  63. data/lib/octoprint/system_commands.rb +110 -0
  64. data/lib/octoprint/timelapse/config.rb +68 -0
  65. data/lib/octoprint/timelapse/file_attributes.rb +50 -0
  66. data/lib/octoprint/timelapse/rendered.rb +51 -0
  67. data/lib/octoprint/timelapse/unrendered.rb +43 -0
  68. data/lib/octoprint/timelapse.rb +221 -0
  69. data/lib/octoprint/types.rb +140 -0
  70. data/lib/octoprint/util.rb +151 -0
  71. data/lib/octoprint/version.rb +7 -0
  72. data/lib/octoprint/wizard.rb +57 -0
  73. data/lib/octoprint.rb +57 -0
  74. data/rbi/octoprint/access/group.rbi +46 -0
  75. data/rbi/octoprint/access/login_response.rbi +22 -0
  76. data/rbi/octoprint/access/permission.rbi +34 -0
  77. data/rbi/octoprint/access/user.rbi +43 -0
  78. data/rbi/octoprint/connection/options.rbi +28 -0
  79. data/rbi/octoprint/connection/settings.rbi +19 -0
  80. data/rbi/octoprint/connection.rbi +13 -0
  81. data/rbi/octoprint/files/file.rbi +61 -0
  82. data/rbi/octoprint/files/folder.rbi +22 -0
  83. data/rbi/octoprint/files/operation_result.rbi +22 -0
  84. data/rbi/octoprint/files/refs.rbi +16 -0
  85. data/rbi/octoprint/job/information.rbi +22 -0
  86. data/rbi/octoprint/job/progress.rbi +25 -0
  87. data/rbi/octoprint/job.rbi +22 -0
  88. data/rbi/octoprint/languages/language_pack.rbi +19 -0
  89. data/rbi/octoprint/languages.rbi +13 -0
  90. data/rbi/octoprint/logs/log_file.rbi +19 -0
  91. data/rbi/octoprint/logs/references.rbi +13 -0
  92. data/rbi/octoprint/logs.rbi +13 -0
  93. data/rbi/octoprint/printer/bed.rbi +22 -0
  94. data/rbi/octoprint/printer/chamber.rbi +22 -0
  95. data/rbi/octoprint/printer/custom_control/input.rbi +22 -0
  96. data/rbi/octoprint/printer/custom_control.rbi +67 -0
  97. data/rbi/octoprint/printer/error_information.rbi +25 -0
  98. data/rbi/octoprint/printer/sd.rbi +13 -0
  99. data/rbi/octoprint/printer/state.rbi +19 -0
  100. data/rbi/octoprint/printer/state_flags.rbi +43 -0
  101. data/rbi/octoprint/printer/temperature_data.rbi +19 -0
  102. data/rbi/octoprint/printer/temperature_data_point.rbi +22 -0
  103. data/rbi/octoprint/printer/temperature_reading.rbi +19 -0
  104. data/rbi/octoprint/printer/temperature_state.rbi +22 -0
  105. data/rbi/octoprint/printer/tool.rbi +22 -0
  106. data/rbi/octoprint/printer.rbi +19 -0
  107. data/rbi/octoprint/printer_profiles/printer_profile.rbi +46 -0
  108. data/rbi/octoprint/printer_profiles.rbi +13 -0
  109. data/rbi/octoprint/server_information.rbi +16 -0
  110. data/rbi/octoprint/server_version.rbi +19 -0
  111. data/rbi/octoprint/settings/webcam.rbi +34 -0
  112. data/rbi/octoprint/slicing/profile.rbi +28 -0
  113. data/rbi/octoprint/slicing/slicer.rbi +31 -0
  114. data/rbi/octoprint/system_commands/command.rbi +25 -0
  115. data/rbi/octoprint/system_commands.rbi +16 -0
  116. data/rbi/octoprint/timelapse/config.rbi +31 -0
  117. data/rbi/octoprint/timelapse/rendered.rbi +31 -0
  118. data/rbi/octoprint/timelapse/unrendered.rbi +34 -0
  119. data/rbi/octoprint/timelapse.rbi +22 -0
  120. data/rbi/octoprint/util.rbi +19 -0
  121. data/rbi/octoprint.rbi +1848 -0
  122. metadata +264 -0
data/rbi/octoprint.rbi ADDED
@@ -0,0 +1,1848 @@
1
+ # typed: true
2
+
3
+ # DO NOT EDIT MANUALLY
4
+ # This is an autogenerated file for types exported from the `octoprint` gem.
5
+ # Please instead update this file by running `bundle exec rake rbi:export`.
6
+
7
+ module Octoprint
8
+ class << self
9
+ sig { returns(T.nilable(::Octoprint::Client)) }
10
+ def client; end
11
+
12
+ def client=(client); end
13
+
14
+ sig do
15
+ params(
16
+ host: ::String,
17
+ api_key: ::String,
18
+ open_timeout: T.nilable(::Numeric),
19
+ timeout: T.nilable(::Numeric)
20
+ ).void
21
+ end
22
+ def configure(host:, api_key:, open_timeout: T.unsafe(nil), timeout: T.unsafe(nil)); end
23
+ end
24
+ end
25
+
26
+ module Octoprint::Access; end
27
+
28
+ class Octoprint::Access::Group
29
+ include ::Octoprint::AutoInitializable
30
+ include ::Octoprint::Deserializable
31
+ extend ::Octoprint::AutoInitializable::ClassMethods
32
+ extend ::Octoprint::Deserializable::ClassMethods
33
+
34
+ def initialize(**kwargs); end
35
+
36
+ def changeable; end
37
+ def dangerous; end
38
+ def default; end
39
+ def description; end
40
+ def extra; end
41
+ def key; end
42
+ def name; end
43
+ def needs; end
44
+ def needs_role; end
45
+ def permissions; end
46
+ def removable; end
47
+ def subgroups; end
48
+ def toggleable; end
49
+ end
50
+
51
+ class Octoprint::Access::Groups < ::Octoprint::BaseResource
52
+ class << self
53
+ sig do
54
+ params(
55
+ key: ::String,
56
+ name: ::String,
57
+ description: ::String,
58
+ permissions: T::Array[::String],
59
+ subgroups: T::Array[::String],
60
+ default: T::Boolean
61
+ ).returns(T::Array[::Octoprint::Access::Group])
62
+ end
63
+ def add(key:, name:, description:, permissions:, subgroups:, default:); end
64
+
65
+ sig do
66
+ params(
67
+ key: T.nilable(::String),
68
+ path: ::String,
69
+ params: T::Hash[::Symbol, T.untyped],
70
+ headers: T::Hash[::Symbol, T.untyped],
71
+ options: T::Hash[::Symbol, T.untyped]
72
+ ).returns(T.untyped)
73
+ end
74
+ def delete(key: T.unsafe(nil), path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
75
+
76
+ sig { params(path: ::String).void }
77
+ def delete_resource(path); end
78
+
79
+ sig { params(key: ::String).returns(::Octoprint::Access::Group) }
80
+ def get(key:); end
81
+
82
+ sig { returns(T::Array[::Octoprint::Access::Group]) }
83
+ def list; end
84
+
85
+ sig { params(key: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T::Array[::Octoprint::Access::Group]) }
86
+ def update(key:, params:); end
87
+ end
88
+ end
89
+
90
+ class Octoprint::Access::LoginResponse
91
+ include ::Octoprint::AutoInitializable
92
+ include ::Octoprint::Deserializable
93
+ extend ::Octoprint::AutoInitializable::ClassMethods
94
+ extend ::Octoprint::Deserializable::ClassMethods
95
+
96
+ def initialize(**kwargs); end
97
+
98
+ def credentials_seen; end
99
+ def is_external_client; end
100
+ def login_mechanism; end
101
+ def session; end
102
+ def user; end
103
+ end
104
+
105
+ Octoprint::Access::LoginResponse::LOGIN_FIELDS = T.let(T.unsafe(nil), Array)
106
+
107
+ class Octoprint::Access::Permission
108
+ include ::Octoprint::AutoInitializable
109
+ include ::Octoprint::Deserializable
110
+ extend ::Octoprint::AutoInitializable::ClassMethods
111
+ extend ::Octoprint::Deserializable::ClassMethods
112
+
113
+ def initialize(**kwargs); end
114
+
115
+ def dangerous; end
116
+ def default_groups; end
117
+ def description; end
118
+ def extra; end
119
+ def key; end
120
+ def name; end
121
+ def needs; end
122
+ def needs_role; end
123
+ def plugin; end
124
+ end
125
+
126
+ class Octoprint::Access::Permissions < ::Octoprint::BaseResource
127
+ class << self
128
+ sig { returns(T::Array[::Octoprint::Access::Permission]) }
129
+ def list; end
130
+ end
131
+ end
132
+
133
+ class Octoprint::Access::User
134
+ include ::Octoprint::AutoInitializable
135
+ include ::Octoprint::Deserializable
136
+ extend ::Octoprint::AutoInitializable::ClassMethods
137
+ extend ::Octoprint::Deserializable::ClassMethods
138
+
139
+ def initialize(**kwargs); end
140
+
141
+ def active; end
142
+ def admin; end
143
+ def api_key; end
144
+ def extra; end
145
+ def groups; end
146
+ def name; end
147
+ def needs; end
148
+ def needs_role; end
149
+ def permissions; end
150
+ def roles; end
151
+ def settings; end
152
+ def user; end
153
+
154
+ class << self
155
+ sig { returns(::Octoprint::Access::User) }
156
+ def current; end
157
+ end
158
+ end
159
+
160
+ class Octoprint::Access::Users < ::Octoprint::BaseResource
161
+ class << self
162
+ sig do
163
+ params(
164
+ name: ::String,
165
+ password: ::String,
166
+ active: T::Boolean,
167
+ admin: T::Boolean,
168
+ groups: T.nilable(T::Array[::String]),
169
+ permissions: T.nilable(T::Array[::String])
170
+ ).returns(T::Array[::Octoprint::Access::User])
171
+ end
172
+ def add(name:, password:, active:, admin:, groups: T.unsafe(nil), permissions: T.unsafe(nil)); end
173
+
174
+ sig { params(username: ::String, password: ::String).returns(T.untyped) }
175
+ def change_password(username:, password:); end
176
+
177
+ sig { returns(::Octoprint::Access::User) }
178
+ def current; end
179
+
180
+ sig do
181
+ params(
182
+ username: T.nilable(::String),
183
+ path: T.nilable(::String),
184
+ params: T.nilable(T::Hash[::Symbol, T.untyped]),
185
+ headers: T.nilable(T::Hash[::Symbol, T.untyped]),
186
+ options: T.nilable(T::Hash[::Symbol, T.untyped])
187
+ ).returns(T.untyped)
188
+ end
189
+ def delete(username: T.unsafe(nil), path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
190
+
191
+ sig { params(username: ::String).returns(T.untyped) }
192
+ def delete_api_key(username:); end
193
+
194
+ sig { params(path: ::String).void }
195
+ def delete_resource(path); end
196
+
197
+ sig { params(username: ::String).returns(::String) }
198
+ def generate_api_key(username:); end
199
+
200
+ sig { params(username: ::String).returns(::Octoprint::Access::User) }
201
+ def get(username:); end
202
+
203
+ sig { params(username: ::String).returns(T::Hash[::Symbol, T.untyped]) }
204
+ def get_settings(username:); end
205
+
206
+ sig { returns(T::Array[::Octoprint::Access::User]) }
207
+ def list; end
208
+
209
+ sig do
210
+ params(
211
+ username: T.nilable(::String),
212
+ password: T.nilable(::String),
213
+ remember: T::Boolean
214
+ ).returns(::Octoprint::Access::LoginResponse)
215
+ end
216
+ def login(username: T.unsafe(nil), password: T.unsafe(nil), remember: T.unsafe(nil)); end
217
+
218
+ sig { returns(T::Boolean) }
219
+ def logout; end
220
+
221
+ sig do
222
+ params(
223
+ username: ::String,
224
+ params: T::Hash[::Symbol, T.untyped]
225
+ ).returns(T::Array[::Octoprint::Access::User])
226
+ end
227
+ def update(username:, params:); end
228
+
229
+ sig { params(username: ::String, settings: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
230
+ def update_settings(username:, settings:); end
231
+
232
+ private
233
+
234
+ sig do
235
+ params(
236
+ username: T.nilable(::String),
237
+ password: T.nilable(::String),
238
+ remember: T::Boolean
239
+ ).returns(T::Hash[::Symbol, T.untyped])
240
+ end
241
+ def login_params(username, password, remember); end
242
+
243
+ sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
244
+ def patch_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
245
+
246
+ sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
247
+ def post_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
248
+
249
+ sig { params(path: ::String, params: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
250
+ def put_with_hash_format(path: T.unsafe(nil), params: T.unsafe(nil)); end
251
+ end
252
+ end
253
+
254
+ module Octoprint::AutoInitializable
255
+ mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
256
+ end
257
+
258
+ module Octoprint::AutoInitializable::ClassMethods
259
+ sig do
260
+ params(
261
+ name: ::Symbol,
262
+ type: T.untyped,
263
+ from: T.nilable(::Symbol),
264
+ array: T::Boolean,
265
+ nilable: T::Boolean
266
+ ).void
267
+ end
268
+ def auto_attr(name, type: T.unsafe(nil), from: T.unsafe(nil), array: T.unsafe(nil), nilable: T.unsafe(nil)); end
269
+
270
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
271
+ def auto_attrs; end
272
+
273
+ sig { void }
274
+ def auto_initialize!; end
275
+
276
+ private
277
+
278
+ sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
279
+ def convert_value(value, type); end
280
+ end
281
+
282
+ class Octoprint::BaseResource
283
+ def initialize(**attrs); end
284
+
285
+ class << self
286
+ sig do
287
+ params(
288
+ path: ::String,
289
+ params: T::Hash[::Symbol, T.untyped],
290
+ headers: T::Hash[::Symbol, T.untyped],
291
+ options: T::Hash[::Symbol, T.untyped]
292
+ ).returns(T.untyped)
293
+ end
294
+ def delete(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
295
+
296
+ def deserialize(attrs); end
297
+ def fetch_resource(path = T.unsafe(nil), deserialize: T.unsafe(nil), options: T.unsafe(nil)); end
298
+
299
+ sig do
300
+ params(
301
+ path: ::String,
302
+ params: T::Hash[::Symbol, T.untyped],
303
+ headers: T::Hash[::Symbol, T.untyped],
304
+ options: T::Hash[::Symbol, T.untyped]
305
+ ).returns(T.untyped)
306
+ end
307
+ def patch(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
308
+
309
+ sig do
310
+ params(
311
+ path: ::String,
312
+ params: T::Hash[::Symbol, T.untyped],
313
+ headers: T::Hash[::Symbol, T.untyped],
314
+ options: T::Hash[::Symbol, T.untyped]
315
+ ).returns(T.untyped)
316
+ end
317
+ def post(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
318
+
319
+ sig do
320
+ params(
321
+ path: ::String,
322
+ params: T::Hash[::Symbol, T.untyped],
323
+ headers: T::Hash[::Symbol, T.untyped],
324
+ options: T::Hash[::Symbol, T.untyped]
325
+ ).returns(T.untyped)
326
+ end
327
+ def put(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
328
+
329
+ def resource_path(path); end
330
+
331
+ private
332
+
333
+ sig { returns(::Octoprint::Client) }
334
+ def client; end
335
+ end
336
+ end
337
+
338
+ class Octoprint::Client
339
+ sig do
340
+ params(
341
+ host: T.nilable(T.any(::String, ::URI::Generic)),
342
+ api_key: T.nilable(::String),
343
+ open_timeout: T.nilable(::Numeric),
344
+ timeout: T.nilable(::Numeric)
345
+ ).void
346
+ end
347
+ def initialize(host:, api_key:, open_timeout: T.unsafe(nil), timeout: T.unsafe(nil)); end
348
+
349
+ def api_key; end
350
+ def client; end
351
+ def host; end
352
+ def open_timeout; end
353
+ def request(path, options_or_http_method = T.unsafe(nil), body: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil), http_method: T.unsafe(nil)); end
354
+ def timeout; end
355
+ def use; end
356
+
357
+ private
358
+
359
+ def new_client(multipart: T.unsafe(nil)); end
360
+ def parse_response(response); end
361
+ def process_error(response); end
362
+ def request_with_client(http_method, path, body, headers, force_multipart: T.unsafe(nil)); end
363
+ def transform_keys_recursively(obj); end
364
+ end
365
+
366
+ Octoprint::Client::DEFAULT_OPEN_TIMEOUT = T.let(T.unsafe(nil), Integer)
367
+ Octoprint::Client::DEFAULT_TIMEOUT = T.let(T.unsafe(nil), Integer)
368
+
369
+ class Octoprint::Connection < ::Octoprint::BaseResource
370
+ include ::Octoprint::AutoInitializable
371
+ extend ::Octoprint::AutoInitializable::ClassMethods
372
+
373
+ def initialize(**kwargs); end
374
+
375
+ def current; end
376
+ def options; end
377
+
378
+ class << self
379
+ def connect(params = T.unsafe(nil)); end
380
+ def disconnect; end
381
+ def fake_ack; end
382
+ def get; end
383
+ end
384
+ end
385
+
386
+ class Octoprint::Connection::Options
387
+ include ::Octoprint::AutoInitializable
388
+ extend ::Octoprint::AutoInitializable::ClassMethods
389
+
390
+ def initialize(**kwargs); end
391
+
392
+ def autoconnect; end
393
+ def baudrate_preference; end
394
+ def baudrates; end
395
+ def port_preference; end
396
+ def ports; end
397
+ def printer_profile_preference; end
398
+ def printer_profiles; end
399
+ end
400
+
401
+ class Octoprint::Connection::Settings
402
+ include ::Octoprint::AutoInitializable
403
+ extend ::Octoprint::AutoInitializable::ClassMethods
404
+
405
+ def initialize(**kwargs); end
406
+
407
+ def baudrate; end
408
+ def port; end
409
+ def printer_profile; end
410
+ def state; end
411
+ end
412
+
413
+ module Octoprint::Deserializable
414
+ mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
415
+ end
416
+
417
+ module Octoprint::Deserializable::ClassMethods
418
+ sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
419
+ def convert_camel_case_keys(data); end
420
+
421
+ sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
422
+ def deserialize(data); end
423
+
424
+ sig do
425
+ params(
426
+ data: T::Hash[::Symbol, T.untyped],
427
+ field: ::Symbol,
428
+ klass: T.untyped
429
+ ).returns(T::Hash[::Symbol, T.untyped])
430
+ end
431
+ def deserialize_array(data, field, klass); end
432
+
433
+ sig { params(block: T.nilable(T.proc.bind(::Octoprint::Deserializable::DeserializationConfig).void)).void }
434
+ def deserialize_config(&block); end
435
+
436
+ sig { returns(T.nilable(::Octoprint::Deserializable::DeserializationConfig)) }
437
+ def deserialize_configuration; end
438
+
439
+ sig do
440
+ params(
441
+ data: T::Hash[::Symbol, T.untyped],
442
+ field: ::Symbol,
443
+ klass: T.untyped
444
+ ).returns(T::Hash[::Symbol, T.untyped])
445
+ end
446
+ def deserialize_nested(data, field, klass); end
447
+
448
+ sig { params(data: T::Hash[::Symbol, T.untyped]).void }
449
+ def handle_extras(data); end
450
+
451
+ sig do
452
+ params(
453
+ data: T::Hash[::Symbol, T.untyped],
454
+ mapping: T::Hash[::Symbol, ::Symbol]
455
+ ).returns(T::Hash[::Symbol, T.untyped])
456
+ end
457
+ def rename_keys(data, mapping); end
458
+
459
+ private
460
+
461
+ sig { params(key: ::Symbol).returns(T::Boolean) }
462
+ def camel_case?(key); end
463
+
464
+ sig { params(camel_key: ::Symbol).returns(::Symbol) }
465
+ def camel_to_snake(camel_key); end
466
+ end
467
+
468
+ class Octoprint::Deserializable::DeserializationConfig
469
+ sig { void }
470
+ def initialize; end
471
+
472
+ sig { params(field: ::Symbol, klass: T.untyped).void }
473
+ def array(field, klass); end
474
+
475
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
476
+ def array_objects; end
477
+
478
+ sig { returns(T::Hash[::Symbol, ::Symbol]) }
479
+ def key_mappings; end
480
+
481
+ sig { params(field: ::Symbol, klass: T.untyped).void }
482
+ def nested(field, klass); end
483
+
484
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
485
+ def nested_objects; end
486
+
487
+ sig { params(mappings: T::Hash[::Symbol, ::Symbol]).void }
488
+ def rename(mappings); end
489
+
490
+ sig { params(block: T.proc.params(data: T::Hash[::Symbol, T.untyped]).void).void }
491
+ def transform(&block); end
492
+
493
+ sig { returns(T::Array[T.proc.params(data: T::Hash[::Symbol, T.untyped]).void]) }
494
+ def transformations; end
495
+ end
496
+
497
+ module Octoprint::Exceptions; end
498
+ class Octoprint::Exceptions::AuthenticationError < ::Octoprint::Exceptions::Error; end
499
+ class Octoprint::Exceptions::BadRequestError < ::Octoprint::Exceptions::Error; end
500
+ class Octoprint::Exceptions::ConflictError < ::Octoprint::Exceptions::Error; end
501
+ class Octoprint::Exceptions::ConnectionError < ::Octoprint::Exceptions::Error; end
502
+ class Octoprint::Exceptions::Error < ::StandardError; end
503
+ class Octoprint::Exceptions::InternalServerError < ::Octoprint::Exceptions::Error; end
504
+ class Octoprint::Exceptions::MissingCredentialsError < ::Octoprint::Exceptions::Error; end
505
+ class Octoprint::Exceptions::NotFoundError < ::Octoprint::Exceptions::Error; end
506
+ class Octoprint::Exceptions::TimeoutError < ::Octoprint::Exceptions::ConnectionError; end
507
+ class Octoprint::Exceptions::UnknownError < ::Octoprint::Exceptions::Error; end
508
+ class Octoprint::Exceptions::UnsupportedMediaTypeError < ::Octoprint::Exceptions::Error; end
509
+
510
+ class Octoprint::Files < ::Octoprint::BaseResource
511
+ def initialize(files:, free: T.unsafe(nil), total: T.unsafe(nil)); end
512
+
513
+ def files; end
514
+ def free; end
515
+ def total; end
516
+
517
+ class << self
518
+ sig { params(filename: ::String, destination: ::String, location: ::Octoprint::Location).returns(T.untyped) }
519
+ def copy(filename:, destination:, location: T.unsafe(nil)); end
520
+
521
+ sig do
522
+ params(
523
+ foldername: ::String,
524
+ location: ::Octoprint::Location,
525
+ path: T.nilable(::String),
526
+ _kargs: T::Hash[::Symbol, T.untyped]
527
+ ).returns(::Octoprint::Files::OperationResult)
528
+ end
529
+ def create_folder(foldername:, location: T.unsafe(nil), path: T.unsafe(nil), **_kargs); end
530
+
531
+ sig { params(filename: ::String, location: ::Octoprint::Location).returns(T.untyped) }
532
+ def delete_file(filename:, location: T.unsafe(nil)); end
533
+
534
+ sig do
535
+ params(
536
+ filename: ::String,
537
+ location: ::Octoprint::Location,
538
+ options: T.nilable(T::Hash[::Symbol, T.untyped])
539
+ ).returns(::Octoprint::Files::File)
540
+ end
541
+ def get(filename:, location: T.unsafe(nil), options: T.unsafe(nil)); end
542
+
543
+ sig do
544
+ params(
545
+ filename: ::String,
546
+ command: ::String,
547
+ location: ::Octoprint::Location,
548
+ options: T::Hash[::Symbol, T.untyped]
549
+ ).returns(T.untyped)
550
+ end
551
+ def issue_command(filename:, command:, location: T.unsafe(nil), options: T.unsafe(nil)); end
552
+
553
+ sig { params(location: ::Octoprint::Location, options: T::Hash[::Symbol, T.untyped]).returns(::Octoprint::Files) }
554
+ def list(location: T.unsafe(nil), options: T.unsafe(nil)); end
555
+
556
+ sig { params(filename: ::String, destination: ::String, location: ::Octoprint::Location).returns(T.untyped) }
557
+ def move(filename:, destination:, location: T.unsafe(nil)); end
558
+
559
+ sig do
560
+ params(
561
+ filename: ::String,
562
+ location: ::Octoprint::Location,
563
+ print: T.nilable(T::Boolean)
564
+ ).returns(T.untyped)
565
+ end
566
+ def select(filename:, location: T.unsafe(nil), print: T.unsafe(nil)); end
567
+
568
+ sig do
569
+ params(
570
+ filename: ::String,
571
+ location: ::Octoprint::Location,
572
+ print: T.nilable(T::Boolean),
573
+ profile: T.nilable(T::Hash[::Symbol, T.untyped])
574
+ ).returns(T.untyped)
575
+ end
576
+ def slice(filename:, location: T.unsafe(nil), print: T.unsafe(nil), profile: T.unsafe(nil)); end
577
+
578
+ sig { params(filename: ::String, location: ::Octoprint::Location).returns(T.untyped) }
579
+ def unselect(filename:, location: T.unsafe(nil)); end
580
+
581
+ sig do
582
+ params(
583
+ file_path: ::String,
584
+ location: ::Octoprint::Location,
585
+ options: {path: T.nilable(::String), select: T.nilable(T::Boolean), print: T.nilable(T::Boolean), userdata: T.nilable(::String)}
586
+ ).returns(::Octoprint::Files::OperationResult)
587
+ end
588
+ def upload(file_path, location: T.unsafe(nil), options: T.unsafe(nil)); end
589
+ end
590
+ end
591
+
592
+ class Octoprint::Files::File
593
+ include ::Octoprint::Deserializable
594
+ include ::Octoprint::AutoInitializable
595
+ extend ::Octoprint::Deserializable::ClassMethods
596
+ extend ::Octoprint::AutoInitializable::ClassMethods
597
+
598
+ def initialize(**kwargs); end
599
+
600
+ def children; end
601
+ def dashboard; end
602
+
603
+ sig { returns(T.nilable(::Time)) }
604
+ def date; end
605
+
606
+ def date_timestamp; end
607
+ def display_layer_progress; end
608
+ def display_name; end
609
+ def extra; end
610
+ def gcode_analysis; end
611
+ def md5_hash; end
612
+ def name; end
613
+ def origin; end
614
+ def path; end
615
+ def prints; end
616
+ def refs; end
617
+ def size; end
618
+ def statistics; end
619
+ def type; end
620
+ def type_path; end
621
+ def userdata; end
622
+ end
623
+
624
+ class Octoprint::Files::Folder
625
+ include ::Octoprint::Deserializable
626
+ include ::Octoprint::AutoInitializable
627
+ extend ::Octoprint::Deserializable::ClassMethods
628
+ extend ::Octoprint::AutoInitializable::ClassMethods
629
+
630
+ def initialize(**kwargs); end
631
+
632
+ def display_name; end
633
+ def name; end
634
+ def origin; end
635
+ def path; end
636
+ def refs; end
637
+ end
638
+
639
+ class Octoprint::Files::OperationResult
640
+ include ::Octoprint::Deserializable
641
+ include ::Octoprint::AutoInitializable
642
+ extend ::Octoprint::Deserializable::ClassMethods
643
+ extend ::Octoprint::AutoInitializable::ClassMethods
644
+
645
+ def initialize(**kwargs); end
646
+
647
+ def done; end
648
+ def effective_print; end
649
+ def effective_select; end
650
+ def files; end
651
+ def folder; end
652
+ end
653
+
654
+ class Octoprint::Files::Refs
655
+ include ::Octoprint::AutoInitializable
656
+ extend ::Octoprint::AutoInitializable::ClassMethods
657
+
658
+ def initialize(**kwargs); end
659
+
660
+ def download; end
661
+ def model; end
662
+ def resource; end
663
+ end
664
+
665
+ class Octoprint::Job < ::Octoprint::BaseResource
666
+ include ::Octoprint::AutoInitializable
667
+ include ::Octoprint::Deserializable
668
+ extend ::Octoprint::AutoInitializable::ClassMethods
669
+ extend ::Octoprint::Deserializable::ClassMethods
670
+
671
+ def initialize(**kwargs); end
672
+
673
+ def error; end
674
+ def extra; end
675
+ def information; end
676
+ def progress; end
677
+ def state; end
678
+
679
+ class << self
680
+ sig { returns(T.untyped) }
681
+ def cancel; end
682
+
683
+ sig { returns(::Octoprint::Job) }
684
+ def get; end
685
+
686
+ sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
687
+ def issue_command(command:, options: T.unsafe(nil)); end
688
+
689
+ sig { returns(T.untyped) }
690
+ def pause; end
691
+
692
+ sig { returns(T.untyped) }
693
+ def restart; end
694
+
695
+ sig { returns(T.untyped) }
696
+ def resume; end
697
+
698
+ sig { returns(T.untyped) }
699
+ def start; end
700
+ end
701
+ end
702
+
703
+ class Octoprint::Job::Information
704
+ include ::Octoprint::AutoInitializable
705
+ include ::Octoprint::Deserializable
706
+ extend ::Octoprint::AutoInitializable::ClassMethods
707
+ extend ::Octoprint::Deserializable::ClassMethods
708
+
709
+ def initialize(**kwargs); end
710
+
711
+ def estimated_print_time; end
712
+ def extra; end
713
+ def filament; end
714
+ def file; end
715
+ def last_print_time; end
716
+ end
717
+
718
+ class Octoprint::Job::Progress
719
+ include ::Octoprint::AutoInitializable
720
+ include ::Octoprint::Deserializable
721
+ extend ::Octoprint::AutoInitializable::ClassMethods
722
+ extend ::Octoprint::Deserializable::ClassMethods
723
+
724
+ def initialize(**kwargs); end
725
+
726
+ def completion; end
727
+ def extra; end
728
+ def filepos; end
729
+ def print_time; end
730
+ def print_time_left; end
731
+ def print_time_left_origin; end
732
+ end
733
+
734
+ class Octoprint::Languages < ::Octoprint::BaseResource
735
+ include ::Octoprint::AutoInitializable
736
+ include ::Octoprint::Deserializable
737
+ extend ::Octoprint::AutoInitializable::ClassMethods
738
+ extend ::Octoprint::Deserializable::ClassMethods
739
+
740
+ def initialize(**kwargs); end
741
+
742
+ def extra; end
743
+ def language_packs; end
744
+
745
+ class << self
746
+ sig { params(locale: ::String, pack: ::String).returns(T.untyped) }
747
+ def delete_pack(locale:, pack:); end
748
+
749
+ sig { returns(::Octoprint::Languages) }
750
+ def list; end
751
+
752
+ sig do
753
+ params(
754
+ file_path: ::String,
755
+ locale: T.nilable(::String)
756
+ ).returns(T::Array[::Octoprint::Languages::LanguagePack])
757
+ end
758
+ def upload(file_path, locale: T.unsafe(nil)); end
759
+ end
760
+ end
761
+
762
+ class Octoprint::Languages::LanguagePack
763
+ include ::Octoprint::Deserializable
764
+ include ::Octoprint::AutoInitializable
765
+ extend ::Octoprint::Deserializable::ClassMethods
766
+ extend ::Octoprint::AutoInitializable::ClassMethods
767
+
768
+ def initialize(**kwargs); end
769
+
770
+ def display; end
771
+ def extra; end
772
+ def identifier; end
773
+ def languages; end
774
+ end
775
+
776
+ class Octoprint::Location < ::T::Enum
777
+ enums do
778
+ Local = new
779
+ SDCard = new
780
+ end
781
+
782
+ sig { returns(::String) }
783
+ def to_s; end
784
+ end
785
+
786
+ class Octoprint::Logs < ::Octoprint::BaseResource
787
+ include ::Octoprint::Deserializable
788
+ include ::Octoprint::AutoInitializable
789
+ extend ::Octoprint::Deserializable::ClassMethods
790
+ extend ::Octoprint::AutoInitializable::ClassMethods
791
+
792
+ def initialize(**kwargs); end
793
+
794
+ def files; end
795
+ def free; end
796
+
797
+ class << self
798
+ sig { params(filename: ::String).returns(T::Boolean) }
799
+ def delete_file(filename:); end
800
+
801
+ sig { returns(::Octoprint::Logs) }
802
+ def list; end
803
+ end
804
+ end
805
+
806
+ class Octoprint::Logs::LogFile
807
+ include ::Octoprint::Deserializable
808
+ include ::Octoprint::AutoInitializable
809
+ extend ::Octoprint::Deserializable::ClassMethods
810
+ extend ::Octoprint::AutoInitializable::ClassMethods
811
+
812
+ def initialize(**kwargs); end
813
+
814
+ def date; end
815
+
816
+ sig { returns(::Time) }
817
+ def modification_time; end
818
+
819
+ def name; end
820
+ def refs; end
821
+ def size; end
822
+
823
+ sig { returns(::String) }
824
+ def to_s; end
825
+ end
826
+
827
+ class Octoprint::Logs::References
828
+ include ::Octoprint::AutoInitializable
829
+ extend ::Octoprint::AutoInitializable::ClassMethods
830
+
831
+ def initialize(**kwargs); end
832
+
833
+ def download; end
834
+ def resource; end
835
+ end
836
+
837
+ class Octoprint::Printer < ::Octoprint::BaseResource
838
+ include ::Octoprint::AutoInitializable
839
+ include ::Octoprint::Deserializable
840
+ extend ::Octoprint::Printer::HistoryQuery
841
+ extend ::Octoprint::AutoInitializable::ClassMethods
842
+ extend ::Octoprint::Deserializable::ClassMethods
843
+
844
+ def initialize(**kwargs); end
845
+
846
+ def extra; end
847
+ def sd; end
848
+ def state; end
849
+ def temperature; end
850
+
851
+ class << self
852
+ sig do
853
+ params(
854
+ history: T::Boolean,
855
+ limit: T.nilable(::Integer),
856
+ exclude: T::Array[T.any(::String, ::Symbol)]
857
+ ).returns(::Octoprint::Printer)
858
+ end
859
+ def get(history: T.unsafe(nil), limit: T.unsafe(nil), exclude: T.unsafe(nil)); end
860
+
861
+ sig { returns(::Octoprint::Printer::ErrorInformation) }
862
+ def last_error; end
863
+ end
864
+ end
865
+
866
+ class Octoprint::Printer::Bed < ::Octoprint::BaseResource
867
+ include ::Octoprint::Printer::Heater
868
+ include ::Octoprint::Printer::TemperatureAttributes
869
+ include ::Octoprint::AutoInitializable
870
+ include ::Octoprint::Deserializable
871
+ extend ::Octoprint::Printer::HistoryQuery
872
+ extend ::Octoprint::Printer::Heater::ClassMethods
873
+ extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
874
+ extend ::Octoprint::AutoInitializable::ClassMethods
875
+ extend ::Octoprint::Deserializable::ClassMethods
876
+
877
+ def initialize(**kwargs); end
878
+
879
+ def actual; end
880
+ def extra; end
881
+ def history; end
882
+ def offset; end
883
+ def target; end
884
+ end
885
+
886
+ class Octoprint::Printer::Chamber < ::Octoprint::BaseResource
887
+ include ::Octoprint::Printer::Heater
888
+ include ::Octoprint::Printer::TemperatureAttributes
889
+ include ::Octoprint::AutoInitializable
890
+ include ::Octoprint::Deserializable
891
+ extend ::Octoprint::Printer::HistoryQuery
892
+ extend ::Octoprint::Printer::Heater::ClassMethods
893
+ extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
894
+ extend ::Octoprint::AutoInitializable::ClassMethods
895
+ extend ::Octoprint::Deserializable::ClassMethods
896
+
897
+ def initialize(**kwargs); end
898
+
899
+ def actual; end
900
+ def extra; end
901
+ def history; end
902
+ def offset; end
903
+ def target; end
904
+ end
905
+
906
+ class Octoprint::Printer::Command < ::Octoprint::BaseResource
907
+ class << self
908
+ sig { returns(T::Array[::Octoprint::Printer::CustomControl]) }
909
+ def custom_controls; end
910
+
911
+ sig do
912
+ params(
913
+ command: T.nilable(::String),
914
+ commands: T.nilable(T::Array[::String]),
915
+ script: T.nilable(::String),
916
+ parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
917
+ context: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
918
+ ).returns(T.untyped)
919
+ end
920
+ def issue(command: T.unsafe(nil), commands: T.unsafe(nil), script: T.unsafe(nil), parameters: T.unsafe(nil), context: T.unsafe(nil)); end
921
+
922
+ sig do
923
+ params(
924
+ script: ::String,
925
+ parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
926
+ context: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
927
+ ).returns(T.untyped)
928
+ end
929
+ def run_script(script, parameters: T.unsafe(nil), context: T.unsafe(nil)); end
930
+
931
+ sig do
932
+ params(
933
+ command: ::String,
934
+ parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
935
+ ).returns(T.untyped)
936
+ end
937
+ def send_command(command, parameters: T.unsafe(nil)); end
938
+
939
+ sig do
940
+ params(
941
+ commands: T::Array[::String],
942
+ parameters: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped])
943
+ ).returns(T.untyped)
944
+ end
945
+ def send_commands(commands, parameters: T.unsafe(nil)); end
946
+ end
947
+ end
948
+
949
+ class Octoprint::Printer::CustomControl
950
+ include ::Octoprint::AutoInitializable
951
+ include ::Octoprint::Deserializable
952
+ extend ::Octoprint::AutoInitializable::ClassMethods
953
+ extend ::Octoprint::Deserializable::ClassMethods
954
+
955
+ def initialize(**kwargs); end
956
+
957
+ def additional_classes; end
958
+ def children; end
959
+ def collapsed; end
960
+ def command; end
961
+ def commands; end
962
+ def confirm; end
963
+
964
+ sig { returns(T::Boolean) }
965
+ def container?; end
966
+
967
+ def enabled; end
968
+ def extra; end
969
+ def input; end
970
+ def javascript; end
971
+ def key; end
972
+ def layout; end
973
+ def name; end
974
+ def offset; end
975
+ def regex; end
976
+ def script; end
977
+ def template; end
978
+ def template_key; end
979
+ def type; end
980
+ def width; end
981
+ end
982
+
983
+ class Octoprint::Printer::CustomControl::Input
984
+ include ::Octoprint::AutoInitializable
985
+ include ::Octoprint::Deserializable
986
+ extend ::Octoprint::AutoInitializable::ClassMethods
987
+ extend ::Octoprint::Deserializable::ClassMethods
988
+
989
+ def initialize(**kwargs); end
990
+
991
+ def default; end
992
+ def extra; end
993
+ def name; end
994
+ def parameter; end
995
+ def slider; end
996
+ end
997
+
998
+ Octoprint::Printer::EXCLUDABLE_FIELDS = T.let(T.unsafe(nil), Array)
999
+
1000
+ class Octoprint::Printer::ErrorInformation < ::Octoprint::BaseResource
1001
+ include ::Octoprint::AutoInitializable
1002
+ include ::Octoprint::Deserializable
1003
+ extend ::Octoprint::AutoInitializable::ClassMethods
1004
+ extend ::Octoprint::Deserializable::ClassMethods
1005
+
1006
+ def initialize(**kwargs); end
1007
+
1008
+ def consequence; end
1009
+ def error; end
1010
+
1011
+ sig { returns(T::Boolean) }
1012
+ def error?; end
1013
+
1014
+ def extra; end
1015
+ def faq; end
1016
+
1017
+ sig { returns(T.nilable(::String)) }
1018
+ def faq_url; end
1019
+
1020
+ def logs; end
1021
+ def reason; end
1022
+
1023
+ class << self
1024
+ sig { returns(::Octoprint::Printer::ErrorInformation) }
1025
+ def get; end
1026
+ end
1027
+ end
1028
+
1029
+ Octoprint::Printer::ErrorInformation::FAQ_BASE_URL = T.let(T.unsafe(nil), String)
1030
+
1031
+ module Octoprint::Printer::Heater
1032
+ include ::Octoprint::AutoInitializable
1033
+ include ::Octoprint::Deserializable
1034
+ include ::Octoprint::Printer::TemperatureAttributes
1035
+
1036
+ mixes_in_class_methods ::Octoprint::Printer::Heater::ClassMethods
1037
+ mixes_in_class_methods ::Octoprint::Printer::TemperatureAttributes::ClassMethods
1038
+ mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
1039
+ mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
1040
+
1041
+ class << self
1042
+ sig { params(base: ::Module).void }
1043
+ def included(base); end
1044
+ end
1045
+ end
1046
+
1047
+ module Octoprint::Printer::Heater::ClassMethods
1048
+ extend T::Generic
1049
+ include ::Octoprint::Printer::HistoryQuery
1050
+
1051
+ has_attached_class!(:out)
1052
+
1053
+ sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
1054
+ def issue_command(command:, options: T.unsafe(nil)); end
1055
+
1056
+ sig { params(offset: ::Numeric).returns(T.untyped) }
1057
+ def offset(offset); end
1058
+
1059
+ sig { params(temperature: ::Numeric).returns(T.untyped) }
1060
+ def target(temperature); end
1061
+
1062
+ sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T.attached_class) }
1063
+ def temperature(history: T.unsafe(nil), limit: T.unsafe(nil)); end
1064
+
1065
+ private
1066
+
1067
+ sig { returns(::Symbol) }
1068
+ def heater_key; end
1069
+ end
1070
+
1071
+ module Octoprint::Printer::HistoryQuery
1072
+ private
1073
+
1074
+ sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T::Hash[::Symbol, T.untyped]) }
1075
+ def history_query(history:, limit:); end
1076
+ end
1077
+
1078
+ class Octoprint::Printer::Printhead < ::Octoprint::BaseResource
1079
+ class << self
1080
+ sig { params(factor: ::Numeric).returns(T.untyped) }
1081
+ def feedrate(factor); end
1082
+
1083
+ sig { params(axes: T::Array[T.any(::String, ::Symbol)]).returns(T.untyped) }
1084
+ def home(axes: T.unsafe(nil)); end
1085
+
1086
+ sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
1087
+ def issue_command(command:, options: T.unsafe(nil)); end
1088
+
1089
+ sig do
1090
+ params(
1091
+ x: T.nilable(::Numeric),
1092
+ y: T.nilable(::Numeric),
1093
+ z: T.nilable(::Numeric),
1094
+ absolute: T.nilable(T::Boolean),
1095
+ speed: T.nilable(T.any(::FalseClass, ::Integer))
1096
+ ).returns(T.untyped)
1097
+ end
1098
+ def jog(x: T.unsafe(nil), y: T.unsafe(nil), z: T.unsafe(nil), absolute: T.unsafe(nil), speed: T.unsafe(nil)); end
1099
+ end
1100
+ end
1101
+
1102
+ class Octoprint::Printer::Sd < ::Octoprint::BaseResource
1103
+ include ::Octoprint::AutoInitializable
1104
+ include ::Octoprint::Deserializable
1105
+ extend ::Octoprint::AutoInitializable::ClassMethods
1106
+ extend ::Octoprint::Deserializable::ClassMethods
1107
+
1108
+ def initialize(**kwargs); end
1109
+
1110
+ def extra; end
1111
+ def ready; end
1112
+
1113
+ class << self
1114
+ sig { returns(::Octoprint::Printer::Sd) }
1115
+ def get; end
1116
+
1117
+ sig { returns(T.untyped) }
1118
+ def init; end
1119
+
1120
+ sig { params(command: ::String).returns(T.untyped) }
1121
+ def issue_command(command:); end
1122
+
1123
+ sig { returns(T.untyped) }
1124
+ def refresh; end
1125
+
1126
+ sig { returns(T.untyped) }
1127
+ def release; end
1128
+ end
1129
+ end
1130
+
1131
+ class Octoprint::Printer::State
1132
+ include ::Octoprint::AutoInitializable
1133
+ include ::Octoprint::Deserializable
1134
+ extend ::Octoprint::AutoInitializable::ClassMethods
1135
+ extend ::Octoprint::Deserializable::ClassMethods
1136
+
1137
+ def initialize(**kwargs); end
1138
+
1139
+ def error; end
1140
+ def extra; end
1141
+ def flags; end
1142
+ def text; end
1143
+ end
1144
+
1145
+ class Octoprint::Printer::StateFlags
1146
+ include ::Octoprint::AutoInitializable
1147
+ include ::Octoprint::Deserializable
1148
+ extend ::Octoprint::AutoInitializable::ClassMethods
1149
+ extend ::Octoprint::Deserializable::ClassMethods
1150
+
1151
+ def initialize(**kwargs); end
1152
+
1153
+ def cancelling; end
1154
+ def closed_or_error; end
1155
+ def error; end
1156
+ def extra; end
1157
+ def finishing; end
1158
+ def operational; end
1159
+ def paused; end
1160
+ def pausing; end
1161
+ def printing; end
1162
+ def ready; end
1163
+ def resuming; end
1164
+ def sd_ready; end
1165
+ end
1166
+
1167
+ module Octoprint::Printer::TemperatureAttributes
1168
+ include ::Octoprint::AutoInitializable
1169
+ include ::Octoprint::Deserializable
1170
+
1171
+ mixes_in_class_methods ::Octoprint::Printer::TemperatureAttributes::ClassMethods
1172
+ mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
1173
+ mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
1174
+
1175
+ class << self
1176
+ sig { params(base: ::Module).void }
1177
+ def included(base); end
1178
+ end
1179
+ end
1180
+
1181
+ module Octoprint::Printer::TemperatureAttributes::ClassMethods
1182
+ sig { params(response: T::Hash[::Symbol, T.untyped], key: ::Symbol).returns(T.untyped) }
1183
+ def from_response(response, key); end
1184
+ end
1185
+
1186
+ class Octoprint::Printer::TemperatureData
1187
+ include ::Octoprint::AutoInitializable
1188
+ include ::Octoprint::Deserializable
1189
+ extend ::Octoprint::AutoInitializable::ClassMethods
1190
+ extend ::Octoprint::Deserializable::ClassMethods
1191
+
1192
+ def initialize(**kwargs); end
1193
+
1194
+ def actual; end
1195
+ def extra; end
1196
+ def offset; end
1197
+ def target; end
1198
+
1199
+ class << self
1200
+ sig { params(data: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
1201
+ def extract_tools(data); end
1202
+ end
1203
+ end
1204
+
1205
+ Octoprint::Printer::TemperatureData::TOOL_KEY = T.let(T.unsafe(nil), Regexp)
1206
+
1207
+ class Octoprint::Printer::TemperatureDataPoint
1208
+ include ::Octoprint::AutoInitializable
1209
+ include ::Octoprint::Deserializable
1210
+ extend ::Octoprint::AutoInitializable::ClassMethods
1211
+ extend ::Octoprint::Deserializable::ClassMethods
1212
+
1213
+ def initialize(**kwargs); end
1214
+
1215
+ def bed; end
1216
+ def chamber; end
1217
+ def extra; end
1218
+
1219
+ sig { returns(T.nilable(::Time)) }
1220
+ def recorded_at; end
1221
+
1222
+ def time; end
1223
+
1224
+ sig { params(index: ::Integer).returns(T.nilable(::Octoprint::Printer::TemperatureData)) }
1225
+ def tool(index = T.unsafe(nil)); end
1226
+
1227
+ def tools; end
1228
+ end
1229
+
1230
+ class Octoprint::Printer::TemperatureReading
1231
+ include ::Octoprint::AutoInitializable
1232
+ include ::Octoprint::Deserializable
1233
+ extend ::Octoprint::AutoInitializable::ClassMethods
1234
+ extend ::Octoprint::Deserializable::ClassMethods
1235
+
1236
+ def initialize(**kwargs); end
1237
+
1238
+ def actual; end
1239
+ def extra; end
1240
+
1241
+ sig { returns(T.nilable(::Time)) }
1242
+ def recorded_at; end
1243
+
1244
+ def target; end
1245
+ def time; end
1246
+ end
1247
+
1248
+ class Octoprint::Printer::TemperatureState
1249
+ include ::Octoprint::AutoInitializable
1250
+ include ::Octoprint::Deserializable
1251
+ extend ::Octoprint::AutoInitializable::ClassMethods
1252
+ extend ::Octoprint::Deserializable::ClassMethods
1253
+
1254
+ def initialize(**kwargs); end
1255
+
1256
+ def bed; end
1257
+ def chamber; end
1258
+ def extra; end
1259
+ def history; end
1260
+
1261
+ sig { params(index: ::Integer).returns(T.nilable(::Octoprint::Printer::TemperatureData)) }
1262
+ def tool(index = T.unsafe(nil)); end
1263
+
1264
+ def tools; end
1265
+ end
1266
+
1267
+ class Octoprint::Printer::Tool < ::Octoprint::BaseResource
1268
+ include ::Octoprint::Printer::TemperatureAttributes
1269
+ include ::Octoprint::AutoInitializable
1270
+ include ::Octoprint::Deserializable
1271
+ extend ::Octoprint::Printer::HistoryQuery
1272
+ extend ::Octoprint::Printer::TemperatureAttributes::ClassMethods
1273
+ extend ::Octoprint::AutoInitializable::ClassMethods
1274
+ extend ::Octoprint::Deserializable::ClassMethods
1275
+
1276
+ def initialize(**kwargs); end
1277
+
1278
+ def actual; end
1279
+ def extra; end
1280
+ def history; end
1281
+ def offset; end
1282
+ def target; end
1283
+
1284
+ class << self
1285
+ sig { params(amount: ::Numeric, speed: T.nilable(::Integer)).returns(T.untyped) }
1286
+ def extrude(amount, speed: T.unsafe(nil)); end
1287
+
1288
+ sig { params(factor: ::Numeric).returns(T.untyped) }
1289
+ def flowrate(factor); end
1290
+
1291
+ sig { params(command: ::String, options: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
1292
+ def issue_command(command:, options: T.unsafe(nil)); end
1293
+
1294
+ sig { params(offsets: T::Hash[T.any(::String, ::Symbol), ::Numeric]).returns(T.untyped) }
1295
+ def offset(offsets); end
1296
+
1297
+ sig { params(tool: T.any(::String, ::Symbol)).returns(T.untyped) }
1298
+ def select_tool(tool); end
1299
+
1300
+ sig { params(targets: T::Hash[T.any(::String, ::Symbol), ::Numeric]).returns(T.untyped) }
1301
+ def target(targets); end
1302
+
1303
+ sig { params(history: T::Boolean, limit: T.nilable(::Integer)).returns(T::Array[::Octoprint::Printer::Tool]) }
1304
+ def temperatures(history: T.unsafe(nil), limit: T.unsafe(nil)); end
1305
+ end
1306
+ end
1307
+
1308
+ class Octoprint::PrinterProfiles < ::Octoprint::BaseResource
1309
+ include ::Octoprint::AutoInitializable
1310
+ include ::Octoprint::Deserializable
1311
+ extend ::Octoprint::AutoInitializable::ClassMethods
1312
+ extend ::Octoprint::Deserializable::ClassMethods
1313
+
1314
+ def initialize(**kwargs); end
1315
+
1316
+ def extra; end
1317
+ def profiles; end
1318
+
1319
+ class << self
1320
+ sig do
1321
+ params(
1322
+ profile: T::Hash[::Symbol, T.untyped],
1323
+ based_on: T.nilable(::String)
1324
+ ).returns(::Octoprint::PrinterProfiles::PrinterProfile)
1325
+ end
1326
+ def create(profile:, based_on: T.unsafe(nil)); end
1327
+
1328
+ sig { params(identifier: ::String).returns(T.untyped) }
1329
+ def delete_profile(identifier:); end
1330
+
1331
+ sig { params(identifier: ::String).returns(::Octoprint::PrinterProfiles::PrinterProfile) }
1332
+ def get(identifier:); end
1333
+
1334
+ sig { returns(::Octoprint::PrinterProfiles) }
1335
+ def list; end
1336
+
1337
+ sig do
1338
+ params(
1339
+ identifier: ::String,
1340
+ profile: T::Hash[::Symbol, T.untyped]
1341
+ ).returns(::Octoprint::PrinterProfiles::PrinterProfile)
1342
+ end
1343
+ def update(identifier:, profile:); end
1344
+
1345
+ private
1346
+
1347
+ sig do
1348
+ params(
1349
+ path: ::String,
1350
+ params: T::Hash[::Symbol, T.untyped],
1351
+ headers: T::Hash[::Symbol, T.untyped],
1352
+ options: T::Hash[::Symbol, T.untyped]
1353
+ ).returns(T.untyped)
1354
+ end
1355
+ def patch(path: T.unsafe(nil), params: T.unsafe(nil), headers: T.unsafe(nil), options: T.unsafe(nil)); end
1356
+ end
1357
+ end
1358
+
1359
+ class Octoprint::PrinterProfiles::PrinterProfile
1360
+ include ::Octoprint::Deserializable
1361
+ include ::Octoprint::AutoInitializable
1362
+ extend ::Octoprint::Deserializable::ClassMethods
1363
+ extend ::Octoprint::AutoInitializable::ClassMethods
1364
+
1365
+ def initialize(**kwargs); end
1366
+
1367
+ def axes; end
1368
+ def color; end
1369
+ def current; end
1370
+ def default; end
1371
+ def extra; end
1372
+ def extruder; end
1373
+ def heated_bed; end
1374
+ def heated_chamber; end
1375
+ def id; end
1376
+ def model; end
1377
+ def name; end
1378
+ def resource; end
1379
+ def volume; end
1380
+ end
1381
+
1382
+ class Octoprint::ServerInformation < ::Octoprint::BaseResource
1383
+ include ::Octoprint::AutoInitializable
1384
+ include ::Octoprint::Deserializable
1385
+ extend ::Octoprint::AutoInitializable::ClassMethods
1386
+ extend ::Octoprint::Deserializable::ClassMethods
1387
+
1388
+ def initialize(**kwargs); end
1389
+
1390
+ def extra; end
1391
+ def safemode; end
1392
+ def version; end
1393
+
1394
+ class << self
1395
+ sig { returns(::Octoprint::ServerInformation) }
1396
+ def get; end
1397
+ end
1398
+ end
1399
+
1400
+ class Octoprint::ServerVersion < ::Octoprint::BaseResource
1401
+ include ::Octoprint::AutoInitializable
1402
+ include ::Octoprint::Deserializable
1403
+ extend ::Octoprint::AutoInitializable::ClassMethods
1404
+ extend ::Octoprint::Deserializable::ClassMethods
1405
+
1406
+ def initialize(**kwargs); end
1407
+
1408
+ def api; end
1409
+ def extra; end
1410
+ def server; end
1411
+ def text; end
1412
+
1413
+ class << self
1414
+ sig { returns(::Octoprint::ServerVersion) }
1415
+ def get; end
1416
+ end
1417
+ end
1418
+
1419
+ class Octoprint::Settings < ::Octoprint::BaseResource
1420
+ class << self
1421
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
1422
+ def fetch_templates; end
1423
+
1424
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
1425
+ def get; end
1426
+
1427
+ sig { returns(T::Hash[::Symbol, ::String]) }
1428
+ def regenerate_api_key; end
1429
+
1430
+ sig { params(settings: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
1431
+ def save(settings); end
1432
+
1433
+ sig { returns(::Octoprint::Settings::Webcam) }
1434
+ def webcam; end
1435
+ end
1436
+ end
1437
+
1438
+ class Octoprint::Settings::Webcam
1439
+ include ::Octoprint::AutoInitializable
1440
+ extend ::Octoprint::AutoInitializable::ClassMethods
1441
+
1442
+ def initialize(**kwargs); end
1443
+
1444
+ def display_name; end
1445
+ def enabled; end
1446
+ def flip_h; end
1447
+ def flip_v; end
1448
+ def name; end
1449
+ def rotate90; end
1450
+ def snapshot_url; end
1451
+ def stream_ratio; end
1452
+ def stream_url; end
1453
+
1454
+ class << self
1455
+ sig { params(settings: T::Hash[::Symbol, T.untyped]).returns(::Octoprint::Settings::Webcam) }
1456
+ def from_settings(settings); end
1457
+
1458
+ private
1459
+
1460
+ sig { params(legacy: T::Hash[::Symbol, T.untyped]).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
1461
+ def default_webcam(legacy); end
1462
+
1463
+ sig { params(legacy: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
1464
+ def legacy_attributes(legacy); end
1465
+
1466
+ sig { params(camera: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
1467
+ def webcam_attributes(camera); end
1468
+ end
1469
+ end
1470
+
1471
+ class Octoprint::Slicing < ::Octoprint::BaseResource
1472
+ class << self
1473
+ sig do
1474
+ params(
1475
+ slicer: ::String,
1476
+ key: ::String,
1477
+ data: T::Hash[T.any(::String, ::Symbol), T.untyped],
1478
+ display_name: T.nilable(::String),
1479
+ description: T.nilable(::String)
1480
+ ).returns(::Octoprint::Slicing::Profile)
1481
+ end
1482
+ def add_profile(slicer:, key:, data: T.unsafe(nil), display_name: T.unsafe(nil), description: T.unsafe(nil)); end
1483
+
1484
+ sig { params(slicer: ::String, key: ::String).returns(::TrueClass) }
1485
+ def delete_profile(slicer:, key:); end
1486
+
1487
+ sig do
1488
+ params(
1489
+ profiles_data: T.nilable(T::Hash[::Symbol, T.untyped])
1490
+ ).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Profile])
1491
+ end
1492
+ def deserialize_profiles(profiles_data); end
1493
+
1494
+ sig { params(slicer: ::String, key: ::String).returns(::Octoprint::Slicing::Profile) }
1495
+ def get_profile(slicer:, key:); end
1496
+
1497
+ sig { params(configured: T::Boolean).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Slicer]) }
1498
+ def list(configured: T.unsafe(nil)); end
1499
+
1500
+ sig { params(slicer: ::String, configured: T::Boolean).returns(T::Hash[::Symbol, ::Octoprint::Slicing::Profile]) }
1501
+ def profiles(slicer:, configured: T.unsafe(nil)); end
1502
+
1503
+ sig do
1504
+ params(
1505
+ slicer: ::String,
1506
+ key: ::String,
1507
+ data: T.nilable(T::Hash[T.any(::String, ::Symbol), T.untyped]),
1508
+ display_name: T.nilable(::String),
1509
+ description: T.nilable(::String),
1510
+ default: T.nilable(T::Boolean)
1511
+ ).returns(::Octoprint::Slicing::Profile)
1512
+ end
1513
+ def update_profile(slicer:, key:, data: T.unsafe(nil), display_name: T.unsafe(nil), description: T.unsafe(nil), default: T.unsafe(nil)); end
1514
+
1515
+ private
1516
+
1517
+ sig { params(configured: T::Boolean).returns(T::Hash[::Symbol, T::Boolean]) }
1518
+ def configured_option(configured); end
1519
+
1520
+ sig { params(slicer: ::String, key: ::String).returns(::String) }
1521
+ def profile_path(slicer, key); end
1522
+
1523
+ sig { params(slicer: ::String, key: ::String).returns(::String) }
1524
+ def profile_subpath(slicer, key); end
1525
+
1526
+ sig { params(slicer: ::String).returns(::String) }
1527
+ def profiles_path(slicer); end
1528
+ end
1529
+ end
1530
+
1531
+ class Octoprint::Slicing::Profile
1532
+ include ::Octoprint::Deserializable
1533
+ include ::Octoprint::AutoInitializable
1534
+ extend ::Octoprint::Deserializable::ClassMethods
1535
+ extend ::Octoprint::AutoInitializable::ClassMethods
1536
+
1537
+ def initialize(**kwargs); end
1538
+
1539
+ def data; end
1540
+ def default; end
1541
+
1542
+ sig { returns(T::Boolean) }
1543
+ def default?; end
1544
+
1545
+ def description; end
1546
+ def display_name; end
1547
+ def extra; end
1548
+ def key; end
1549
+ def resource; end
1550
+ end
1551
+
1552
+ class Octoprint::Slicing::Slicer
1553
+ include ::Octoprint::Deserializable
1554
+ include ::Octoprint::AutoInitializable
1555
+ extend ::Octoprint::Deserializable::ClassMethods
1556
+ extend ::Octoprint::AutoInitializable::ClassMethods
1557
+
1558
+ def initialize(**kwargs); end
1559
+
1560
+ def configured; end
1561
+
1562
+ sig { returns(T::Boolean) }
1563
+ def configured?; end
1564
+
1565
+ def default; end
1566
+
1567
+ sig { returns(T::Boolean) }
1568
+ def default?; end
1569
+
1570
+ def display_name; end
1571
+ def extensions; end
1572
+ def extra; end
1573
+ def key; end
1574
+ def profiles; end
1575
+ def same_device; end
1576
+ end
1577
+
1578
+ class Octoprint::SystemCommands < ::Octoprint::BaseResource
1579
+ include ::Octoprint::Deserializable
1580
+ include ::Octoprint::AutoInitializable
1581
+ extend ::Octoprint::Deserializable::ClassMethods
1582
+ extend ::Octoprint::AutoInitializable::ClassMethods
1583
+
1584
+ def initialize(**kwargs); end
1585
+
1586
+ def core; end
1587
+ def custom; end
1588
+ def extra; end
1589
+
1590
+ class << self
1591
+ sig { params(source: ::String, action: ::String).returns(T::Boolean) }
1592
+ def execute(source, action); end
1593
+
1594
+ sig { returns(::Octoprint::SystemCommands) }
1595
+ def list; end
1596
+
1597
+ sig { params(source: ::String).returns(T::Array[::Octoprint::SystemCommands::Command]) }
1598
+ def list_by_source(source); end
1599
+ end
1600
+ end
1601
+
1602
+ class Octoprint::SystemCommands::Command
1603
+ include ::Octoprint::Deserializable
1604
+ include ::Octoprint::AutoInitializable
1605
+ extend ::Octoprint::Deserializable::ClassMethods
1606
+ extend ::Octoprint::AutoInitializable::ClassMethods
1607
+
1608
+ def initialize(**kwargs); end
1609
+
1610
+ def action; end
1611
+ def confirm; end
1612
+ def extra; end
1613
+ def name; end
1614
+ def resource; end
1615
+ def source; end
1616
+ end
1617
+
1618
+ class Octoprint::Timelapse < ::Octoprint::BaseResource
1619
+ include ::Octoprint::AutoInitializable
1620
+ include ::Octoprint::Deserializable
1621
+ extend ::Octoprint::AutoInitializable::ClassMethods
1622
+ extend ::Octoprint::Deserializable::ClassMethods
1623
+
1624
+ def initialize(**kwargs); end
1625
+
1626
+ def config; end
1627
+ def enabled; end
1628
+ def extra; end
1629
+ def files; end
1630
+ def unrendered; end
1631
+
1632
+ class << self
1633
+ sig { params(filename: ::String, unrendered: T::Boolean).returns(::Octoprint::Timelapse) }
1634
+ def delete_file(filename:, unrendered: T.unsafe(nil)); end
1635
+
1636
+ sig { params(name: ::String).returns(T.untyped) }
1637
+ def delete_unrendered(name:); end
1638
+
1639
+ sig { params(unrendered: T::Boolean, force: T::Boolean).returns(::Octoprint::Timelapse) }
1640
+ def get(unrendered: T.unsafe(nil), force: T.unsafe(nil)); end
1641
+
1642
+ sig { params(name: ::String, command: ::String).returns(T.untyped) }
1643
+ def issue_unrendered_command(name:, command:); end
1644
+
1645
+ sig { params(name: ::String).returns(T.untyped) }
1646
+ def render(name:); end
1647
+
1648
+ sig do
1649
+ params(
1650
+ type: ::String,
1651
+ post_roll: T.nilable(::Integer),
1652
+ fps: T.nilable(::Integer),
1653
+ interval: T.nilable(::Integer),
1654
+ retraction_z_hop: T.nilable(::Numeric),
1655
+ min_delay: T.nilable(::Numeric),
1656
+ render_after_print: T.nilable(::String),
1657
+ save: T::Boolean,
1658
+ unrendered: T::Boolean
1659
+ ).returns(::Octoprint::Timelapse)
1660
+ end
1661
+ def update_config(type:, post_roll: T.unsafe(nil), fps: T.unsafe(nil), interval: T.unsafe(nil), retraction_z_hop: T.unsafe(nil), min_delay: T.unsafe(nil), render_after_print: T.unsafe(nil), save: T.unsafe(nil), unrendered: T.unsafe(nil)); end
1662
+
1663
+ private
1664
+
1665
+ sig { params(name: ::String).returns(::String) }
1666
+ def escape(name); end
1667
+
1668
+ sig { params(flags: T::Boolean).returns(T::Hash[::Symbol, T::Boolean]) }
1669
+ def query(**flags); end
1670
+
1671
+ sig { params(path: ::String, options: T::Hash[::Symbol, T.untyped]).returns(::String) }
1672
+ def with_query(path, options); end
1673
+ end
1674
+ end
1675
+
1676
+ class Octoprint::Timelapse::Config
1677
+ include ::Octoprint::AutoInitializable
1678
+ include ::Octoprint::Deserializable
1679
+ extend ::Octoprint::AutoInitializable::ClassMethods
1680
+ extend ::Octoprint::Deserializable::ClassMethods
1681
+
1682
+ def initialize(**kwargs); end
1683
+
1684
+ def extra; end
1685
+ def fps; end
1686
+ def interval; end
1687
+ def min_delay; end
1688
+
1689
+ sig { returns(T::Boolean) }
1690
+ def off?; end
1691
+
1692
+ def post_roll; end
1693
+ def render_after_print; end
1694
+ def retraction_z_hop; end
1695
+ def type; end
1696
+ end
1697
+
1698
+ module Octoprint::Timelapse::FileAttributes
1699
+ include ::Octoprint::AutoInitializable
1700
+ include ::Octoprint::Deserializable
1701
+
1702
+ mixes_in_class_methods ::Octoprint::AutoInitializable::ClassMethods
1703
+ mixes_in_class_methods ::Octoprint::Deserializable::ClassMethods
1704
+
1705
+ class << self
1706
+ sig { params(base: ::Module).void }
1707
+ def included(base); end
1708
+ end
1709
+ end
1710
+
1711
+ class Octoprint::Timelapse::Rendered
1712
+ include ::Octoprint::AutoInitializable
1713
+ include ::Octoprint::Deserializable
1714
+ include ::Octoprint::Timelapse::FileAttributes
1715
+ extend ::Octoprint::AutoInitializable::ClassMethods
1716
+ extend ::Octoprint::Deserializable::ClassMethods
1717
+
1718
+ def initialize(**kwargs); end
1719
+
1720
+ def bytes; end
1721
+ def date; end
1722
+ def extra; end
1723
+
1724
+ sig { returns(T.nilable(::Time)) }
1725
+ def modification_time; end
1726
+
1727
+ def name; end
1728
+ def size; end
1729
+ def thumbnail; end
1730
+ def timestamp; end
1731
+ def url; end
1732
+ end
1733
+
1734
+ Octoprint::Timelapse::TYPES = T.let(T.unsafe(nil), Array)
1735
+
1736
+ class Octoprint::Timelapse::Unrendered
1737
+ include ::Octoprint::AutoInitializable
1738
+ include ::Octoprint::Deserializable
1739
+ include ::Octoprint::Timelapse::FileAttributes
1740
+ extend ::Octoprint::AutoInitializable::ClassMethods
1741
+ extend ::Octoprint::Deserializable::ClassMethods
1742
+
1743
+ def initialize(**kwargs); end
1744
+
1745
+ def bytes; end
1746
+ def count; end
1747
+ def date; end
1748
+ def extra; end
1749
+ def name; end
1750
+ def processing; end
1751
+ def recording; end
1752
+ def rendering; end
1753
+ def size; end
1754
+ end
1755
+
1756
+ module Octoprint::Types; end
1757
+ Octoprint::Types::BaudRate = Integer
1758
+ Octoprint::Types::BedTemperature = Float
1759
+ Octoprint::Types::ConnectionState = String
1760
+ Octoprint::Types::ExtruderCount = Integer
1761
+ Octoprint::Types::FilePath = String
1762
+ Octoprint::Types::FileSize = Integer
1763
+ Octoprint::Types::Hostname = String
1764
+ Octoprint::Types::Iso8601String = String
1765
+ Octoprint::Types::JobState = String
1766
+ Octoprint::Types::Port = Integer
1767
+ Octoprint::Types::PrintTime = Integer
1768
+ Octoprint::Types::PrinterId = String
1769
+ Octoprint::Types::ProgressPercent = Float
1770
+ Octoprint::Types::SerialPort = String
1771
+ Octoprint::Types::UnixTimestamp = Integer
1772
+ Octoprint::Types::Url = String
1773
+ Octoprint::User = Octoprint::Access::User
1774
+
1775
+ class Octoprint::Util < ::Octoprint::BaseResource
1776
+ include ::Octoprint::AutoInitializable
1777
+ include ::Octoprint::Deserializable
1778
+ extend ::Octoprint::AutoInitializable::ClassMethods
1779
+ extend ::Octoprint::Deserializable::ClassMethods
1780
+
1781
+ def initialize(**kwargs); end
1782
+
1783
+ def exists; end
1784
+ def extra; end
1785
+ def result; end
1786
+ def status; end
1787
+
1788
+ class << self
1789
+ sig { params(address: T.nilable(::String)).returns(::Octoprint::Util) }
1790
+ def test_address(address: T.unsafe(nil)); end
1791
+
1792
+ sig do
1793
+ params(
1794
+ path: ::String,
1795
+ check_type: T.nilable(::String),
1796
+ check_access: T.nilable(::String),
1797
+ allow_create_dir: T.nilable(T::Boolean),
1798
+ check_writable_dir: T.nilable(T::Boolean)
1799
+ ).returns(::Octoprint::Util)
1800
+ end
1801
+ def test_path(path:, check_type: T.unsafe(nil), check_access: T.unsafe(nil), allow_create_dir: T.unsafe(nil), check_writable_dir: T.unsafe(nil)); end
1802
+
1803
+ sig { params(name: ::String).returns(::Octoprint::Util) }
1804
+ def test_resolution(name:); end
1805
+
1806
+ sig do
1807
+ params(
1808
+ host: ::String,
1809
+ port: ::Integer,
1810
+ protocol: T.nilable(::String),
1811
+ timeout: T.nilable(::Float)
1812
+ ).returns(::Octoprint::Util)
1813
+ end
1814
+ def test_server(host:, port:, protocol: T.unsafe(nil), timeout: T.unsafe(nil)); end
1815
+
1816
+ sig do
1817
+ params(
1818
+ url: ::String,
1819
+ method: T.nilable(::String),
1820
+ timeout: T.nilable(::Integer),
1821
+ status: T.nilable(::Integer),
1822
+ auth_user: T.nilable(::String),
1823
+ auth_pass: T.nilable(::String),
1824
+ auth_digest: T.nilable(::String),
1825
+ auth_bearer: T.nilable(::String),
1826
+ content_type_whitelist: T.nilable(::String),
1827
+ content_type_blacklist: T.nilable(::String)
1828
+ ).returns(::Octoprint::Util)
1829
+ end
1830
+ def test_url(url:, method: T.unsafe(nil), timeout: T.unsafe(nil), status: T.unsafe(nil), auth_user: T.unsafe(nil), auth_pass: T.unsafe(nil), auth_digest: T.unsafe(nil), auth_bearer: T.unsafe(nil), content_type_whitelist: T.unsafe(nil), content_type_blacklist: T.unsafe(nil)); end
1831
+
1832
+ private
1833
+
1834
+ def build_url_test_params(url, options); end
1835
+ end
1836
+ end
1837
+
1838
+ Octoprint::VERSION = T.let(T.unsafe(nil), String)
1839
+
1840
+ class Octoprint::Wizard < ::Octoprint::BaseResource
1841
+ class << self
1842
+ sig { params(handled: T::Array[::String]).returns(T.untyped) }
1843
+ def finish(handled:); end
1844
+
1845
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
1846
+ def get; end
1847
+ end
1848
+ end