reposets 0.4.1 → 0.4.2

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 (27) hide show
  1. package/README.md +15 -14
  2. package/bin/reposets.d.ts +1 -0
  3. package/bin/reposets.js +25 -507
  4. package/cli/commands/credentials.js +74 -0
  5. package/cli/commands/doctor.js +154 -0
  6. package/cli/commands/init.js +147 -0
  7. package/cli/commands/list.js +49 -0
  8. package/cli/commands/sync.js +70 -0
  9. package/cli/commands/validate.js +53 -0
  10. package/errors.js +12 -0
  11. package/index.d.ts +1750 -1840
  12. package/index.js +19 -2
  13. package/lib/crypto.js +27 -0
  14. package/package.json +61 -73
  15. package/schemas/common.js +130 -0
  16. package/schemas/config.js +469 -0
  17. package/schemas/credentials.js +78 -0
  18. package/schemas/environment.js +70 -0
  19. package/schemas/ruleset.js +545 -0
  20. package/services/ConfigFiles.js +119 -0
  21. package/services/CredentialResolver.js +40 -0
  22. package/services/GitHubClient.js +875 -0
  23. package/services/OnePasswordClient.js +30 -0
  24. package/services/SyncEngine.js +580 -0
  25. package/services/SyncLogger.js +106 -0
  26. package/tsdoc-metadata.json +11 -11
  27. package/500.js +0 -3354
package/index.d.ts CHANGED
@@ -1,1840 +1,1750 @@
1
- /**
2
- * reposets
3
- *
4
- * CLI tool to sync GitHub repo settings, secrets, and rulesets
5
- * across personal repositories.
6
- *
7
- * @packageDocumentation
8
- */
9
-
10
- import { AppDirs } from 'xdg-effect';
11
- import { ConfigFile } from 'xdg-effect';
12
- import { ConfigFileService } from 'xdg-effect';
13
- import { Context } from 'effect';
14
- import { Effect } from 'effect';
15
- import { FileSystem } from '@effect/platform/FileSystem';
16
- import { Layer } from 'effect/Layer';
17
- import { Layer as Layer_2 } from 'effect';
18
- import { Option } from 'effect';
19
- import { Ref } from 'effect';
20
- import { Schema } from 'effect';
21
- import { Tag } from 'effect/Context';
22
- import { VoidIfEmpty } from 'effect/Types';
23
- import { ConfigError as XdgConfigError } from 'xdg-effect';
24
- import { XdgResolver } from 'xdg-effect';
25
- import { YieldableError } from 'effect/Cause';
26
-
27
- export { AppDirs }
28
-
29
- /**
30
- * Builds an API-compatible ruleset payload from the config-level Ruleset.
31
- * Converts all shorthand fields into the GitHub API rules array format.
32
- */
33
- export declare function buildRulesetPayload(ruleset: Ruleset): RulesetPayload;
34
-
35
- export declare type BypassActor = typeof BypassActorSchema.Type;
36
-
37
- export declare const BypassActorSchema: Schema.Struct<{
38
- actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
39
- resolved: Schema.SchemaClass<string, string, never>;
40
- }>]>>;
41
- actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
42
- bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
43
- default: () => "always";
44
- }>;
45
- }>;
46
-
47
- export declare type Cleanup = typeof CleanupSchema.Type;
48
-
49
- export declare const CleanupSchema: Schema.Struct<{
50
- secrets: Schema.optionalWith<Schema.Struct<{
51
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
52
- preserve: Schema.Array$<typeof Schema.String>;
53
- }>]>, {
54
- default: () => CleanupScope;
55
- }>;
56
- dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
57
- preserve: Schema.Array$<typeof Schema.String>;
58
- }>]>, {
59
- default: () => CleanupScope;
60
- }>;
61
- codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
62
- preserve: Schema.Array$<typeof Schema.String>;
63
- }>]>, {
64
- default: () => CleanupScope;
65
- }>;
66
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
67
- preserve: Schema.Array$<typeof Schema.String>;
68
- }>]>, {
69
- default: () => CleanupScope;
70
- }>;
71
- }>, {
72
- default: () => {
73
- actions: CleanupScope;
74
- dependabot: CleanupScope;
75
- codespaces: CleanupScope;
76
- environments: CleanupScope;
77
- };
78
- }>;
79
- variables: Schema.optionalWith<Schema.Struct<{
80
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
81
- preserve: Schema.Array$<typeof Schema.String>;
82
- }>]>, {
83
- default: () => CleanupScope;
84
- }>;
85
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
86
- preserve: Schema.Array$<typeof Schema.String>;
87
- }>]>, {
88
- default: () => CleanupScope;
89
- }>;
90
- }>, {
91
- default: () => {
92
- actions: CleanupScope;
93
- environments: CleanupScope;
94
- };
95
- }>;
96
- rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
97
- preserve: Schema.Array$<typeof Schema.String>;
98
- }>]>, {
99
- default: () => CleanupScope;
100
- }>;
101
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
102
- preserve: Schema.Array$<typeof Schema.String>;
103
- }>]>, {
104
- default: () => CleanupScope;
105
- }>;
106
- }>;
107
-
108
- export declare type CleanupScope = typeof CleanupScopeSchema.Type;
109
-
110
- export declare const CleanupScopeSchema: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
111
- preserve: Schema.Array$<typeof Schema.String>;
112
- }>]>;
113
-
114
- declare type CodeScanningGroup = typeof CodeScanningGroupSchema.Type;
115
-
116
- declare const CodeScanningGroupSchema: Schema.refine<{
117
- readonly state?: "configured" | "not-configured" | undefined;
118
- readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
119
- readonly query_suite?: "default" | "extended" | undefined;
120
- readonly threat_model?: "remote" | "remote_and_local" | undefined;
121
- readonly runner_type?: "labeled" | "standard" | undefined;
122
- readonly runner_label?: string | undefined;
123
- }, Schema.Struct<{
124
- state: Schema.optional<Schema.Literal<["configured", "not-configured"]>>;
125
- languages: Schema.optional<Schema.Array$<Schema.Literal<["actions", "c-cpp", "csharp", "go", "java-kotlin", "javascript-typescript", "python", "ruby", "swift"]>>>;
126
- query_suite: Schema.optional<Schema.Literal<["default", "extended"]>>;
127
- threat_model: Schema.optional<Schema.Literal<["remote", "remote_and_local"]>>;
128
- runner_type: Schema.optional<Schema.Literal<["standard", "labeled"]>>;
129
- runner_label: Schema.optional<Schema.SchemaClass<string, string, never>>;
130
- }>>;
131
-
132
- export declare type Config = typeof ConfigSchema.Type;
133
-
134
- export declare const CONFIG_FILENAME = "reposets.config.toml";
135
-
136
- export { ConfigFile }
137
-
138
- /**
139
- * Default ConfigFiles layer with no --config flag override.
140
- * Used by CLI entrypoint when no flag is provided.
141
- */
142
- export declare const ConfigFilesLive: Layer<AppDirs | ConfigFileService<any> | XdgResolver, never, FileSystem>;
143
-
144
- export declare const ConfigSchema: Schema.Struct<{
145
- owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
146
- log_level: Schema.optionalWith<Schema.Literal<["silent", "info", "verbose", "debug"]>, {
147
- default: () => "info";
148
- }>;
149
- settings: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.TypeLiteral<{
150
- is_template: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
151
- has_wiki: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
152
- has_issues: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
153
- has_projects: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
154
- has_discussions: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
155
- has_sponsorships: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
156
- has_pull_requests: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
157
- allow_forking: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
158
- allow_merge_commit: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
159
- allow_squash_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
160
- allow_rebase_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
161
- allow_auto_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
162
- allow_update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
163
- squash_merge_commit_title: Schema.optional<Schema.Literal<["PR_TITLE", "COMMIT_OR_PR_TITLE"]>>;
164
- squash_merge_commit_message: Schema.optional<Schema.Literal<["PR_BODY", "COMMIT_MESSAGES", "BLANK"]>>;
165
- merge_commit_title: Schema.optional<Schema.Literal<["PR_TITLE", "MERGE_MESSAGE"]>>;
166
- merge_commit_message: Schema.optional<Schema.Literal<["PR_BODY", "PR_TITLE", "BLANK"]>>;
167
- delete_branch_on_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
168
- web_commit_signoff_required: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
169
- security_and_analysis: Schema.optional<Schema.Struct<{
170
- advanced_security: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
171
- code_security: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
172
- secret_scanning: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
173
- secret_scanning_push_protection: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
174
- secret_scanning_ai_detection: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
175
- secret_scanning_non_provider_patterns: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
176
- secret_scanning_delegated_alert_dismissal: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
177
- secret_scanning_delegated_bypass: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
178
- delegated_bypass_reviewers: Schema.optional<Schema.Array$<Schema.Union<[Schema.Struct<{
179
- team: Schema.SchemaClass<string, string, never>;
180
- mode: Schema.optional<Schema.Literal<["ALWAYS", "EXEMPT"]>>;
181
- }>, Schema.Struct<{
182
- role: Schema.SchemaClass<string, string, never>;
183
- mode: Schema.optional<Schema.Literal<["ALWAYS", "EXEMPT"]>>;
184
- }>]>>>;
185
- dependabot_security_updates: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
186
- }>>;
187
- }, readonly [{
188
- readonly key: typeof Schema.String;
189
- readonly value: Schema.SchemaClass<unknown, unknown, never>;
190
- }]>>, {
191
- default: () => {};
192
- }>;
193
- secrets: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
194
- file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
195
- }>, Schema.Struct<{
196
- value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
197
- }>, Schema.Struct<{
198
- resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
199
- }>]>>, {
200
- default: () => {};
201
- }>;
202
- variables: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
203
- file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
204
- }>, Schema.Struct<{
205
- value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
206
- }>, Schema.Struct<{
207
- resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
208
- }>]>>, {
209
- default: () => {};
210
- }>;
211
- rulesets: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
212
- name: Schema.SchemaClass<string, string, never>;
213
- enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
214
- conditions: Schema.optional<Schema.Struct<{
215
- ref_name: Schema.optional<Schema.Struct<{
216
- include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
217
- default: () => never[];
218
- }>;
219
- exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
220
- default: () => never[];
221
- }>;
222
- }>>;
223
- }>>;
224
- bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
225
- actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
226
- resolved: Schema.SchemaClass<string, string, never>;
227
- }>]>>;
228
- actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
229
- bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
230
- default: () => "always";
231
- }>;
232
- }>>>;
233
- creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
234
- update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
235
- deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
236
- required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
237
- required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
238
- non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
239
- deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
240
- targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
241
- include: Schema.SchemaClass<string, string, never>;
242
- }>, Schema.Struct<{
243
- exclude: Schema.SchemaClass<string, string, never>;
244
- }>]>>]>>;
245
- status_checks: Schema.optional<Schema.Struct<{
246
- update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
247
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
248
- default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
249
- resolved: Schema.SchemaClass<string, string, never>;
250
- }>]>>;
251
- required: Schema.Array$<Schema.Struct<{
252
- context: Schema.SchemaClass<string, string, never>;
253
- integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
254
- resolved: Schema.SchemaClass<string, string, never>;
255
- }>]>>;
256
- }>>;
257
- }>>;
258
- commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
259
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
260
- pattern: Schema.SchemaClass<string, string, never>;
261
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
262
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
263
- }>>>;
264
- commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
265
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
266
- pattern: Schema.SchemaClass<string, string, never>;
267
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
268
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
269
- }>>>;
270
- committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
271
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
272
- pattern: Schema.SchemaClass<string, string, never>;
273
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
274
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
275
- }>>>;
276
- type: Schema.Literal<["branch"]>;
277
- pull_requests: Schema.optional<Schema.Struct<{
278
- approvals: Schema.optionalWith<Schema.refine<number, typeof Schema.Int>, {
279
- default: () => number;
280
- }>;
281
- dismiss_stale_reviews: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
282
- default: () => boolean;
283
- }>;
284
- code_owner_review: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
285
- default: () => boolean;
286
- }>;
287
- last_push_approval: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
288
- default: () => boolean;
289
- }>;
290
- resolve_threads: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
291
- default: () => boolean;
292
- }>;
293
- merge_methods: Schema.optional<Schema.Array$<Schema.Literal<["merge", "squash", "rebase"]>>>;
294
- reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
295
- file_patterns: Schema.Array$<typeof Schema.String>;
296
- minimum_approvals: Schema.refine<number, typeof Schema.Number>;
297
- reviewer: Schema.Struct<{
298
- id: Schema.refine<number, typeof Schema.Number>;
299
- type: Schema.Literal<["Team"]>;
300
- }>;
301
- }>>>;
302
- }>>;
303
- merge_queue: Schema.optional<Schema.Struct<{
304
- check_timeout: Schema.refine<number, typeof Schema.Int>;
305
- grouping: Schema.Literal<["ALLGREEN", "HEADGREEN"]>;
306
- max_build: Schema.refine<number, typeof Schema.Int>;
307
- max_merge: Schema.refine<number, typeof Schema.Int>;
308
- merge_method: Schema.Literal<["MERGE", "SQUASH", "REBASE"]>;
309
- min_merge: Schema.refine<number, typeof Schema.Int>;
310
- min_wait: Schema.refine<number, typeof Schema.Int>;
311
- }>>;
312
- copilot_review: Schema.optional<Schema.Struct<{
313
- draft_prs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
314
- on_push: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
315
- }>>;
316
- code_scanning: Schema.optional<Schema.Array$<Schema.Struct<{
317
- tool: Schema.SchemaClass<string, string, never>;
318
- alerts: Schema.Literal<["none", "errors", "errors_and_warnings", "all"]>;
319
- security_alerts: Schema.Literal<["none", "critical", "high_or_higher", "medium_or_higher", "all"]>;
320
- }>>>;
321
- workflows: Schema.optional<Schema.Struct<{
322
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
323
- required: Schema.Array$<Schema.Struct<{
324
- path: Schema.SchemaClass<string, string, never>;
325
- ref: Schema.optional<Schema.SchemaClass<string, string, never>>;
326
- repository_id: Schema.Union<[typeof Schema.Int, Schema.Struct<{
327
- resolved: Schema.SchemaClass<string, string, never>;
328
- }>]>;
329
- sha: Schema.optional<Schema.SchemaClass<string, string, never>>;
330
- }>>;
331
- }>>;
332
- branch_name: Schema.optional<Schema.Array$<Schema.Struct<{
333
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
334
- pattern: Schema.SchemaClass<string, string, never>;
335
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
336
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
337
- }>>>;
338
- }>, Schema.Struct<{
339
- name: Schema.SchemaClass<string, string, never>;
340
- enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
341
- conditions: Schema.optional<Schema.Struct<{
342
- ref_name: Schema.optional<Schema.Struct<{
343
- include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
344
- default: () => never[];
345
- }>;
346
- exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
347
- default: () => never[];
348
- }>;
349
- }>>;
350
- }>>;
351
- bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
352
- actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
353
- resolved: Schema.SchemaClass<string, string, never>;
354
- }>]>>;
355
- actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
356
- bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
357
- default: () => "always";
358
- }>;
359
- }>>>;
360
- creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
361
- update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
362
- deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
363
- required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
364
- required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
365
- non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
366
- deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
367
- targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
368
- include: Schema.SchemaClass<string, string, never>;
369
- }>, Schema.Struct<{
370
- exclude: Schema.SchemaClass<string, string, never>;
371
- }>]>>]>>;
372
- status_checks: Schema.optional<Schema.Struct<{
373
- update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
374
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
375
- default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
376
- resolved: Schema.SchemaClass<string, string, never>;
377
- }>]>>;
378
- required: Schema.Array$<Schema.Struct<{
379
- context: Schema.SchemaClass<string, string, never>;
380
- integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
381
- resolved: Schema.SchemaClass<string, string, never>;
382
- }>]>>;
383
- }>>;
384
- }>>;
385
- commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
386
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
387
- pattern: Schema.SchemaClass<string, string, never>;
388
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
389
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
390
- }>>>;
391
- commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
392
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
393
- pattern: Schema.SchemaClass<string, string, never>;
394
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
395
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
396
- }>>>;
397
- committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
398
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
399
- pattern: Schema.SchemaClass<string, string, never>;
400
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
401
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
402
- }>>>;
403
- type: Schema.Literal<["tag"]>;
404
- tag_name: Schema.optional<Schema.Array$<Schema.Struct<{
405
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
406
- pattern: Schema.SchemaClass<string, string, never>;
407
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
408
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
409
- }>>>;
410
- }>]>>, {
411
- default: () => {};
412
- }>;
413
- environments: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
414
- wait_timer: Schema.optional<Schema.refine<number, typeof Schema.Int>>;
415
- prevent_self_review: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
416
- reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
417
- type: Schema.Literal<["User", "Team"]>;
418
- id: Schema.refine<number, typeof Schema.Number>;
419
- }>>>;
420
- deployment_branches: Schema.optional<Schema.Union<[Schema.Literal<["all", "protected"]>, Schema.Array$<Schema.Struct<{
421
- name: Schema.SchemaClass<string, string, never>;
422
- type: Schema.optionalWith<Schema.Literal<["branch", "tag"]>, {
423
- default: () => "branch";
424
- }>;
425
- }>>]>>;
426
- }>>, {
427
- default: () => {};
428
- }>;
429
- security: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.refine<{
430
- readonly vulnerability_alerts?: boolean | undefined;
431
- readonly automated_security_fixes?: boolean | undefined;
432
- readonly private_vulnerability_reporting?: boolean | undefined;
433
- }, Schema.Struct<{
434
- vulnerability_alerts: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
435
- automated_security_fixes: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
436
- private_vulnerability_reporting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
437
- }>>>, {
438
- default: () => {};
439
- }>;
440
- code_scanning: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.refine<{
441
- readonly state?: "configured" | "not-configured" | undefined;
442
- readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
443
- readonly query_suite?: "default" | "extended" | undefined;
444
- readonly threat_model?: "remote" | "remote_and_local" | undefined;
445
- readonly runner_type?: "labeled" | "standard" | undefined;
446
- readonly runner_label?: string | undefined;
447
- }, Schema.Struct<{
448
- state: Schema.optional<Schema.Literal<["configured", "not-configured"]>>;
449
- languages: Schema.optional<Schema.Array$<Schema.Literal<["actions", "c-cpp", "csharp", "go", "java-kotlin", "javascript-typescript", "python", "ruby", "swift"]>>>;
450
- query_suite: Schema.optional<Schema.Literal<["default", "extended"]>>;
451
- threat_model: Schema.optional<Schema.Literal<["remote", "remote_and_local"]>>;
452
- runner_type: Schema.optional<Schema.Literal<["standard", "labeled"]>>;
453
- runner_label: Schema.optional<Schema.SchemaClass<string, string, never>>;
454
- }>>>, {
455
- default: () => {};
456
- }>;
457
- groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
458
- owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
459
- repos: Schema.Array$<typeof Schema.String>;
460
- credentials: Schema.optional<Schema.SchemaClass<string, string, never>>;
461
- settings: Schema.optional<Schema.Array$<typeof Schema.String>>;
462
- environments: Schema.optional<Schema.Array$<typeof Schema.String>>;
463
- secrets: Schema.optional<Schema.Struct<{
464
- actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
465
- dependabot: Schema.optional<Schema.Array$<typeof Schema.String>>;
466
- codespaces: Schema.optional<Schema.Array$<typeof Schema.String>>;
467
- environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
468
- }>>;
469
- variables: Schema.optional<Schema.Struct<{
470
- actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
471
- environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
472
- }>>;
473
- rulesets: Schema.optional<Schema.Array$<typeof Schema.String>>;
474
- security: Schema.optional<Schema.Array$<typeof Schema.String>>;
475
- code_scanning: Schema.optional<Schema.Array$<typeof Schema.String>>;
476
- cleanup: Schema.optional<Schema.Struct<{
477
- secrets: Schema.optionalWith<Schema.Struct<{
478
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
479
- preserve: Schema.Array$<typeof Schema.String>;
480
- }>]>, {
481
- default: () => CleanupScope;
482
- }>;
483
- dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
484
- preserve: Schema.Array$<typeof Schema.String>;
485
- }>]>, {
486
- default: () => CleanupScope;
487
- }>;
488
- codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
489
- preserve: Schema.Array$<typeof Schema.String>;
490
- }>]>, {
491
- default: () => CleanupScope;
492
- }>;
493
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
494
- preserve: Schema.Array$<typeof Schema.String>;
495
- }>]>, {
496
- default: () => CleanupScope;
497
- }>;
498
- }>, {
499
- default: () => {
500
- actions: CleanupScope;
501
- dependabot: CleanupScope;
502
- codespaces: CleanupScope;
503
- environments: CleanupScope;
504
- };
505
- }>;
506
- variables: Schema.optionalWith<Schema.Struct<{
507
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
508
- preserve: Schema.Array$<typeof Schema.String>;
509
- }>]>, {
510
- default: () => CleanupScope;
511
- }>;
512
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
513
- preserve: Schema.Array$<typeof Schema.String>;
514
- }>]>, {
515
- default: () => CleanupScope;
516
- }>;
517
- }>, {
518
- default: () => {
519
- actions: CleanupScope;
520
- environments: CleanupScope;
521
- };
522
- }>;
523
- rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
524
- preserve: Schema.Array$<typeof Schema.String>;
525
- }>]>, {
526
- default: () => CleanupScope;
527
- }>;
528
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
529
- preserve: Schema.Array$<typeof Schema.String>;
530
- }>]>, {
531
- default: () => CleanupScope;
532
- }>;
533
- }>>;
534
- }>>;
535
- }>;
536
-
537
- export declare type CredentialProfile = typeof CredentialProfileSchema.Type;
538
-
539
- export declare const CredentialProfileSchema: Schema.Struct<{
540
- github_token: Schema.SchemaClass<string, string, never>;
541
- op_service_account_token: Schema.optional<Schema.SchemaClass<string, string, never>>;
542
- resolve: Schema.optional<Schema.Struct<{
543
- op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
544
- file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
545
- value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
546
- }>>;
547
- }>;
548
-
549
- export declare class CredentialResolver extends CredentialResolver_base {
550
- }
551
-
552
- declare const CredentialResolver_base: Context.TagClass<CredentialResolver, "CredentialResolver", CredentialResolverService>;
553
-
554
- export declare const CredentialResolverLive: Layer_2.Layer<CredentialResolver, never, OnePasswordClient>;
555
-
556
- declare interface CredentialResolverService {
557
- readonly resolveAll: (profile: CredentialProfile, basePath: string) => Effect.Effect<Map<string, string>, ResolveError>;
558
- }
559
-
560
- export declare type Credentials = typeof CredentialsSchema.Type;
561
-
562
- export declare const CREDENTIALS_FILENAME = "reposets.credentials.toml";
563
-
564
- export declare const CredentialsSchema: Schema.Struct<{
565
- profiles: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
566
- github_token: Schema.SchemaClass<string, string, never>;
567
- op_service_account_token: Schema.optional<Schema.SchemaClass<string, string, never>>;
568
- resolve: Schema.optional<Schema.Struct<{
569
- op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
570
- file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
571
- value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
572
- }>>;
573
- }>>, {
574
- default: () => {};
575
- }>;
576
- }>;
577
-
578
- /**
579
- * Encrypt a secret using libsodium's sealed box algorithm.
580
- * Implementation based on tweetsodium using tweetnacl + blakejs.
581
- *
582
- * The sealed box format is: ephemeral_public_key (32 bytes) || ciphertext
583
- */
584
- export declare function encryptSecret(publicKey: string, secretValue: string): string;
585
-
586
- declare interface EnvironmentInfo {
587
- name: string;
588
- }
589
-
590
- export declare class GitHubApiError extends GitHubApiError_base<{
591
- readonly message: string;
592
- readonly status?: number;
593
- }> {
594
- }
595
-
596
- declare const GitHubApiError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty< { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
597
- readonly _tag: "GitHubApiError";
598
- } & Readonly<A>;
599
-
600
- export declare class GitHubClient extends GitHubClient_base {
601
- }
602
-
603
- declare const GitHubClient_base: Context.TagClass<GitHubClient, "GitHubClient", GitHubClientService>;
604
-
605
- export declare function GitHubClientLive(token: string): Layer_2.Layer<GitHubClient>;
606
-
607
- declare interface GitHubClientService {
608
- readonly getOwnerType: (owner: string) => Effect.Effect<OwnerType, GitHubApiError>;
609
- readonly syncSecret: (owner: string, repo: string, name: string, value: string, scope: SecretScope) => Effect.Effect<void, GitHubApiError>;
610
- readonly syncVariable: (owner: string, repo: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
611
- readonly syncSettings: (owner: string, repo: string, settings: Record<string, unknown>) => Effect.Effect<void, GitHubApiError>;
612
- readonly syncRuleset: (owner: string, repo: string, name: string, payload: RulesetPayload) => Effect.Effect<void, GitHubApiError>;
613
- readonly listSecrets: (owner: string, repo: string, scope: SecretScope) => Effect.Effect<SecretInfo[], GitHubApiError>;
614
- readonly listVariables: (owner: string, repo: string) => Effect.Effect<VariableInfo[], GitHubApiError>;
615
- readonly listRulesets: (owner: string, repo: string) => Effect.Effect<RulesetInfo[], GitHubApiError>;
616
- readonly deleteSecret: (owner: string, repo: string, name: string, scope: SecretScope) => Effect.Effect<void, GitHubApiError>;
617
- readonly deleteVariable: (owner: string, repo: string, name: string) => Effect.Effect<void, GitHubApiError>;
618
- readonly deleteRuleset: (owner: string, repo: string, rulesetId: number) => Effect.Effect<void, GitHubApiError>;
619
- readonly syncEnvironment: (owner: string, repo: string, name: string, config: Record<string, unknown>) => Effect.Effect<void, GitHubApiError>;
620
- readonly syncEnvironmentSecret: (owner: string, repo: string, envName: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
621
- readonly syncEnvironmentVariable: (owner: string, repo: string, envName: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
622
- readonly listEnvironments: (owner: string, repo: string) => Effect.Effect<EnvironmentInfo[], GitHubApiError>;
623
- readonly listEnvironmentSecrets: (owner: string, repo: string, envName: string) => Effect.Effect<SecretInfo[], GitHubApiError>;
624
- readonly listEnvironmentVariables: (owner: string, repo: string, envName: string) => Effect.Effect<VariableInfo[], GitHubApiError>;
625
- readonly deleteEnvironment: (owner: string, repo: string, name: string) => Effect.Effect<void, GitHubApiError>;
626
- readonly deleteEnvironmentSecret: (owner: string, repo: string, envName: string, name: string) => Effect.Effect<void, GitHubApiError>;
627
- readonly deleteEnvironmentVariable: (owner: string, repo: string, envName: string, name: string) => Effect.Effect<void, GitHubApiError>;
628
- readonly getVulnerabilityAlerts: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
629
- readonly setVulnerabilityAlerts: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
630
- readonly getAutomatedSecurityFixes: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
631
- readonly setAutomatedSecurityFixes: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
632
- readonly getPrivateVulnerabilityReporting: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
633
- readonly setPrivateVulnerabilityReporting: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
634
- readonly updateCodeScanningDefaultSetup: (owner: string, repo: string, config: CodeScanningGroup) => Effect.Effect<void, GitHubApiError>;
635
- readonly listRepoLanguages: (owner: string, repo: string) => Effect.Effect<ReadonlyArray<string>, GitHubApiError>;
636
- readonly resolveTeamId: (org: string, slug: string) => Effect.Effect<number, GitHubApiError>;
637
- readonly resolveRoleId: (org: string, name: string) => Effect.Effect<number, GitHubApiError>;
638
- }
639
-
640
- export declare function GitHubClientTest(): {
641
- layer: Layer_2.Layer<GitHubClient>;
642
- calls: () => RecordedCall[];
643
- };
644
-
645
- export declare type Group = typeof GroupSchema.Type;
646
-
647
- export declare const GroupSchema: Schema.Struct<{
648
- owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
649
- repos: Schema.Array$<typeof Schema.String>;
650
- credentials: Schema.optional<Schema.SchemaClass<string, string, never>>;
651
- settings: Schema.optional<Schema.Array$<typeof Schema.String>>;
652
- environments: Schema.optional<Schema.Array$<typeof Schema.String>>;
653
- secrets: Schema.optional<Schema.Struct<{
654
- actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
655
- dependabot: Schema.optional<Schema.Array$<typeof Schema.String>>;
656
- codespaces: Schema.optional<Schema.Array$<typeof Schema.String>>;
657
- environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
658
- }>>;
659
- variables: Schema.optional<Schema.Struct<{
660
- actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
661
- environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
662
- }>>;
663
- rulesets: Schema.optional<Schema.Array$<typeof Schema.String>>;
664
- security: Schema.optional<Schema.Array$<typeof Schema.String>>;
665
- code_scanning: Schema.optional<Schema.Array$<typeof Schema.String>>;
666
- cleanup: Schema.optional<Schema.Struct<{
667
- secrets: Schema.optionalWith<Schema.Struct<{
668
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
669
- preserve: Schema.Array$<typeof Schema.String>;
670
- }>]>, {
671
- default: () => CleanupScope;
672
- }>;
673
- dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
674
- preserve: Schema.Array$<typeof Schema.String>;
675
- }>]>, {
676
- default: () => CleanupScope;
677
- }>;
678
- codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
679
- preserve: Schema.Array$<typeof Schema.String>;
680
- }>]>, {
681
- default: () => CleanupScope;
682
- }>;
683
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
684
- preserve: Schema.Array$<typeof Schema.String>;
685
- }>]>, {
686
- default: () => CleanupScope;
687
- }>;
688
- }>, {
689
- default: () => {
690
- actions: CleanupScope;
691
- dependabot: CleanupScope;
692
- codespaces: CleanupScope;
693
- environments: CleanupScope;
694
- };
695
- }>;
696
- variables: Schema.optionalWith<Schema.Struct<{
697
- actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
698
- preserve: Schema.Array$<typeof Schema.String>;
699
- }>]>, {
700
- default: () => CleanupScope;
701
- }>;
702
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
703
- preserve: Schema.Array$<typeof Schema.String>;
704
- }>]>, {
705
- default: () => CleanupScope;
706
- }>;
707
- }>, {
708
- default: () => {
709
- actions: CleanupScope;
710
- environments: CleanupScope;
711
- };
712
- }>;
713
- rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
714
- preserve: Schema.Array$<typeof Schema.String>;
715
- }>]>, {
716
- default: () => CleanupScope;
717
- }>;
718
- environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
719
- preserve: Schema.Array$<typeof Schema.String>;
720
- }>]>, {
721
- default: () => CleanupScope;
722
- }>;
723
- }>>;
724
- }>;
725
-
726
- export declare type LogLevel = typeof LogLevelSchema.Type;
727
-
728
- export declare const LogLevelSchema: Schema.Literal<["silent", "info", "verbose", "debug"]>;
729
-
730
- /**
731
- * Creates a live Layer providing both config and credentials file services.
732
- * When configFlag is Some and points to a directory, prepends StaticDir resolver.
733
- * When configFlag is Some and points to a file, prepends ExplicitPath resolver.
734
- * Always includes UpwardWalk + XdgConfigResolver as fallback resolvers.
735
- * Passes validateConfigRefs as the validate callback on the config spec.
736
- */
737
- export declare function makeConfigFilesLive(configFlag: Option.Option<string>): Layer<AppDirs | ConfigFileService<any> | XdgResolver, never, FileSystem>;
738
-
739
- export declare class OnePasswordClient extends OnePasswordClient_base {
740
- }
741
-
742
- declare const OnePasswordClient_base: Context.TagClass<OnePasswordClient, "OnePasswordClient", OnePasswordClientService>;
743
-
744
- export declare const OnePasswordClientLive: Layer_2.Layer<OnePasswordClient, never, never>;
745
-
746
- declare interface OnePasswordClientService {
747
- readonly resolve: (reference: string, serviceAccountToken: string) => Effect.Effect<string, OnePasswordError>;
748
- }
749
-
750
- export declare function OnePasswordClientTest(stubs: Record<string, string>): Layer_2.Layer<OnePasswordClient>;
751
-
752
- export declare class OnePasswordError extends OnePasswordError_base<{
753
- readonly message: string;
754
- }> {
755
- }
756
-
757
- declare const OnePasswordError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty< { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
758
- readonly _tag: "OnePasswordError";
759
- } & Readonly<A>;
760
-
761
- declare type OwnerType = "User" | "Organization";
762
-
763
- export declare interface RecordedCall {
764
- method: string;
765
- args: Record<string, unknown>;
766
- }
767
-
768
- export declare const ReposetsConfigFile: Tag<ConfigFileService< {
769
- readonly owner?: string | undefined;
770
- readonly log_level: "debug" | "info" | "silent" | "verbose";
771
- readonly settings: {
772
- readonly [x: string]: {
773
- readonly [x: string]: unknown;
774
- readonly is_template?: boolean | undefined;
775
- readonly has_wiki?: boolean | undefined;
776
- readonly has_issues?: boolean | undefined;
777
- readonly has_projects?: boolean | undefined;
778
- readonly has_discussions?: boolean | undefined;
779
- readonly has_sponsorships?: boolean | undefined;
780
- readonly has_pull_requests?: boolean | undefined;
781
- readonly allow_forking?: boolean | undefined;
782
- readonly allow_merge_commit?: boolean | undefined;
783
- readonly allow_squash_merge?: boolean | undefined;
784
- readonly allow_rebase_merge?: boolean | undefined;
785
- readonly allow_auto_merge?: boolean | undefined;
786
- readonly allow_update_branch?: boolean | undefined;
787
- readonly squash_merge_commit_title?: "COMMIT_OR_PR_TITLE" | "PR_TITLE" | undefined;
788
- readonly squash_merge_commit_message?: "BLANK" | "COMMIT_MESSAGES" | "PR_BODY" | undefined;
789
- readonly merge_commit_title?: "MERGE_MESSAGE" | "PR_TITLE" | undefined;
790
- readonly merge_commit_message?: "BLANK" | "PR_BODY" | "PR_TITLE" | undefined;
791
- readonly delete_branch_on_merge?: boolean | undefined;
792
- readonly web_commit_signoff_required?: boolean | undefined;
793
- readonly security_and_analysis?: {
794
- readonly advanced_security?: "disabled" | "enabled" | undefined;
795
- readonly code_security?: "disabled" | "enabled" | undefined;
796
- readonly secret_scanning?: "disabled" | "enabled" | undefined;
797
- readonly secret_scanning_push_protection?: "disabled" | "enabled" | undefined;
798
- readonly secret_scanning_ai_detection?: "disabled" | "enabled" | undefined;
799
- readonly secret_scanning_non_provider_patterns?: "disabled" | "enabled" | undefined;
800
- readonly secret_scanning_delegated_alert_dismissal?: "disabled" | "enabled" | undefined;
801
- readonly secret_scanning_delegated_bypass?: "disabled" | "enabled" | undefined;
802
- readonly delegated_bypass_reviewers?: readonly ({
803
- readonly team: string;
804
- readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
805
- } | {
806
- readonly role: string;
807
- readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
808
- })[] | undefined;
809
- readonly dependabot_security_updates?: "disabled" | "enabled" | undefined;
810
- } | undefined;
811
- };
812
- };
813
- readonly secrets: {
814
- readonly [x: string]: {
815
- readonly file: {
816
- readonly [x: string]: string;
817
- };
818
- } | {
819
- readonly value: {
820
- readonly [x: string]: string | {
821
- readonly [x: string]: unknown;
822
- };
823
- };
824
- } | {
825
- readonly resolved: {
826
- readonly [x: string]: string;
827
- };
828
- };
829
- };
830
- readonly variables: {
831
- readonly [x: string]: {
832
- readonly file: {
833
- readonly [x: string]: string;
834
- };
835
- } | {
836
- readonly value: {
837
- readonly [x: string]: string | {
838
- readonly [x: string]: unknown;
839
- };
840
- };
841
- } | {
842
- readonly resolved: {
843
- readonly [x: string]: string;
844
- };
845
- };
846
- };
847
- readonly rulesets: {
848
- readonly [x: string]: {
849
- readonly name: string;
850
- readonly enforcement: "active" | "disabled" | "evaluate";
851
- readonly conditions?: {
852
- readonly ref_name?: {
853
- readonly include: readonly string[];
854
- readonly exclude: readonly string[];
855
- } | undefined;
856
- } | undefined;
857
- readonly bypass_actors?: readonly {
858
- readonly actor_id?: number | {
859
- readonly resolved: string;
860
- } | undefined;
861
- readonly actor_type: "DeployKey" | "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team";
862
- readonly bypass_mode: "always" | "exempt" | "pull_request";
863
- }[] | undefined;
864
- readonly creation?: boolean | undefined;
865
- readonly update?: boolean | undefined;
866
- readonly deletion?: boolean | undefined;
867
- readonly required_linear_history?: boolean | undefined;
868
- readonly required_signatures?: boolean | undefined;
869
- readonly non_fast_forward?: boolean | undefined;
870
- readonly deployments?: readonly string[] | undefined;
871
- readonly targets?: "all" | "default" | readonly ({
872
- readonly include: string;
873
- } | {
874
- readonly exclude: string;
875
- })[] | undefined;
876
- readonly status_checks?: {
877
- readonly update_branch?: boolean | undefined;
878
- readonly on_creation?: boolean | undefined;
879
- readonly default_integration_id?: number | {
880
- readonly resolved: string;
881
- } | undefined;
882
- readonly required: readonly {
883
- readonly context: string;
884
- readonly integration_id?: number | {
885
- readonly resolved: string;
886
- } | undefined;
887
- }[];
888
- } | undefined;
889
- readonly commit_message?: readonly {
890
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
891
- readonly pattern: string;
892
- readonly name?: string | undefined;
893
- readonly negate?: boolean | undefined;
894
- }[] | undefined;
895
- readonly commit_author_email?: readonly {
896
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
897
- readonly pattern: string;
898
- readonly name?: string | undefined;
899
- readonly negate?: boolean | undefined;
900
- }[] | undefined;
901
- readonly committer_email?: readonly {
902
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
903
- readonly pattern: string;
904
- readonly name?: string | undefined;
905
- readonly negate?: boolean | undefined;
906
- }[] | undefined;
907
- readonly type: "branch";
908
- readonly pull_requests?: {
909
- readonly approvals: number;
910
- readonly dismiss_stale_reviews: boolean;
911
- readonly code_owner_review: boolean;
912
- readonly last_push_approval: boolean;
913
- readonly resolve_threads: boolean;
914
- readonly merge_methods?: readonly ("merge" | "rebase" | "squash")[] | undefined;
915
- readonly reviewers?: readonly {
916
- readonly file_patterns: readonly string[];
917
- readonly minimum_approvals: number;
918
- readonly reviewer: {
919
- readonly id: number;
920
- readonly type: "Team";
921
- };
922
- }[] | undefined;
923
- } | undefined;
924
- readonly merge_queue?: {
925
- readonly check_timeout: number;
926
- readonly grouping: "ALLGREEN" | "HEADGREEN";
927
- readonly max_build: number;
928
- readonly max_merge: number;
929
- readonly merge_method: "MERGE" | "REBASE" | "SQUASH";
930
- readonly min_merge: number;
931
- readonly min_wait: number;
932
- } | undefined;
933
- readonly copilot_review?: {
934
- readonly draft_prs?: boolean | undefined;
935
- readonly on_push?: boolean | undefined;
936
- } | undefined;
937
- readonly code_scanning?: readonly {
938
- readonly tool: string;
939
- readonly alerts: "all" | "errors" | "errors_and_warnings" | "none";
940
- readonly security_alerts: "all" | "critical" | "high_or_higher" | "medium_or_higher" | "none";
941
- }[] | undefined;
942
- readonly workflows?: {
943
- readonly on_creation?: boolean | undefined;
944
- readonly required: readonly {
945
- readonly path: string;
946
- readonly ref?: string | undefined;
947
- readonly repository_id: number | {
948
- readonly resolved: string;
949
- };
950
- readonly sha?: string | undefined;
951
- }[];
952
- } | undefined;
953
- readonly branch_name?: readonly {
954
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
955
- readonly pattern: string;
956
- readonly name?: string | undefined;
957
- readonly negate?: boolean | undefined;
958
- }[] | undefined;
959
- } | {
960
- readonly name: string;
961
- readonly enforcement: "active" | "disabled" | "evaluate";
962
- readonly conditions?: {
963
- readonly ref_name?: {
964
- readonly include: readonly string[];
965
- readonly exclude: readonly string[];
966
- } | undefined;
967
- } | undefined;
968
- readonly bypass_actors?: readonly {
969
- readonly actor_id?: number | {
970
- readonly resolved: string;
971
- } | undefined;
972
- readonly actor_type: "DeployKey" | "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team";
973
- readonly bypass_mode: "always" | "exempt" | "pull_request";
974
- }[] | undefined;
975
- readonly creation?: boolean | undefined;
976
- readonly update?: boolean | undefined;
977
- readonly deletion?: boolean | undefined;
978
- readonly required_linear_history?: boolean | undefined;
979
- readonly required_signatures?: boolean | undefined;
980
- readonly non_fast_forward?: boolean | undefined;
981
- readonly deployments?: readonly string[] | undefined;
982
- readonly targets?: "all" | "default" | readonly ({
983
- readonly include: string;
984
- } | {
985
- readonly exclude: string;
986
- })[] | undefined;
987
- readonly status_checks?: {
988
- readonly update_branch?: boolean | undefined;
989
- readonly on_creation?: boolean | undefined;
990
- readonly default_integration_id?: number | {
991
- readonly resolved: string;
992
- } | undefined;
993
- readonly required: readonly {
994
- readonly context: string;
995
- readonly integration_id?: number | {
996
- readonly resolved: string;
997
- } | undefined;
998
- }[];
999
- } | undefined;
1000
- readonly commit_message?: readonly {
1001
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1002
- readonly pattern: string;
1003
- readonly name?: string | undefined;
1004
- readonly negate?: boolean | undefined;
1005
- }[] | undefined;
1006
- readonly commit_author_email?: readonly {
1007
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1008
- readonly pattern: string;
1009
- readonly name?: string | undefined;
1010
- readonly negate?: boolean | undefined;
1011
- }[] | undefined;
1012
- readonly committer_email?: readonly {
1013
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1014
- readonly pattern: string;
1015
- readonly name?: string | undefined;
1016
- readonly negate?: boolean | undefined;
1017
- }[] | undefined;
1018
- readonly type: "tag";
1019
- readonly tag_name?: readonly {
1020
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1021
- readonly pattern: string;
1022
- readonly name?: string | undefined;
1023
- readonly negate?: boolean | undefined;
1024
- }[] | undefined;
1025
- };
1026
- };
1027
- readonly environments: {
1028
- readonly [x: string]: {
1029
- readonly wait_timer?: number | undefined;
1030
- readonly prevent_self_review?: boolean | undefined;
1031
- readonly reviewers?: readonly {
1032
- readonly type: "Team" | "User";
1033
- readonly id: number;
1034
- }[] | undefined;
1035
- readonly deployment_branches?: "all" | "protected" | readonly {
1036
- readonly name: string;
1037
- readonly type: "branch" | "tag";
1038
- }[] | undefined;
1039
- };
1040
- };
1041
- readonly security: {
1042
- readonly [x: string]: {
1043
- readonly vulnerability_alerts?: boolean | undefined;
1044
- readonly automated_security_fixes?: boolean | undefined;
1045
- readonly private_vulnerability_reporting?: boolean | undefined;
1046
- };
1047
- };
1048
- readonly code_scanning: {
1049
- readonly [x: string]: {
1050
- readonly state?: "configured" | "not-configured" | undefined;
1051
- readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
1052
- readonly query_suite?: "default" | "extended" | undefined;
1053
- readonly threat_model?: "remote" | "remote_and_local" | undefined;
1054
- readonly runner_type?: "labeled" | "standard" | undefined;
1055
- readonly runner_label?: string | undefined;
1056
- };
1057
- };
1058
- readonly groups: {
1059
- readonly [x: string]: {
1060
- readonly owner?: string | undefined;
1061
- readonly repos: readonly string[];
1062
- readonly credentials?: string | undefined;
1063
- readonly settings?: readonly string[] | undefined;
1064
- readonly environments?: readonly string[] | undefined;
1065
- readonly secrets?: {
1066
- readonly actions?: readonly string[] | undefined;
1067
- readonly dependabot?: readonly string[] | undefined;
1068
- readonly codespaces?: readonly string[] | undefined;
1069
- readonly environments?: {
1070
- readonly [x: string]: readonly string[];
1071
- } | undefined;
1072
- } | undefined;
1073
- readonly variables?: {
1074
- readonly actions?: readonly string[] | undefined;
1075
- readonly environments?: {
1076
- readonly [x: string]: readonly string[];
1077
- } | undefined;
1078
- } | undefined;
1079
- readonly rulesets?: readonly string[] | undefined;
1080
- readonly security?: readonly string[] | undefined;
1081
- readonly code_scanning?: readonly string[] | undefined;
1082
- readonly cleanup?: {
1083
- readonly secrets: {
1084
- readonly actions: boolean | {
1085
- readonly preserve: readonly string[];
1086
- };
1087
- readonly dependabot: boolean | {
1088
- readonly preserve: readonly string[];
1089
- };
1090
- readonly codespaces: boolean | {
1091
- readonly preserve: readonly string[];
1092
- };
1093
- readonly environments: boolean | {
1094
- readonly preserve: readonly string[];
1095
- };
1096
- };
1097
- readonly variables: {
1098
- readonly actions: boolean | {
1099
- readonly preserve: readonly string[];
1100
- };
1101
- readonly environments: boolean | {
1102
- readonly preserve: readonly string[];
1103
- };
1104
- };
1105
- readonly rulesets: boolean | {
1106
- readonly preserve: readonly string[];
1107
- };
1108
- readonly environments: boolean | {
1109
- readonly preserve: readonly string[];
1110
- };
1111
- } | undefined;
1112
- };
1113
- };
1114
- }>, ConfigFileService< {
1115
- readonly owner?: string | undefined;
1116
- readonly log_level: "debug" | "info" | "silent" | "verbose";
1117
- readonly settings: {
1118
- readonly [x: string]: {
1119
- readonly [x: string]: unknown;
1120
- readonly is_template?: boolean | undefined;
1121
- readonly has_wiki?: boolean | undefined;
1122
- readonly has_issues?: boolean | undefined;
1123
- readonly has_projects?: boolean | undefined;
1124
- readonly has_discussions?: boolean | undefined;
1125
- readonly has_sponsorships?: boolean | undefined;
1126
- readonly has_pull_requests?: boolean | undefined;
1127
- readonly allow_forking?: boolean | undefined;
1128
- readonly allow_merge_commit?: boolean | undefined;
1129
- readonly allow_squash_merge?: boolean | undefined;
1130
- readonly allow_rebase_merge?: boolean | undefined;
1131
- readonly allow_auto_merge?: boolean | undefined;
1132
- readonly allow_update_branch?: boolean | undefined;
1133
- readonly squash_merge_commit_title?: "COMMIT_OR_PR_TITLE" | "PR_TITLE" | undefined;
1134
- readonly squash_merge_commit_message?: "BLANK" | "COMMIT_MESSAGES" | "PR_BODY" | undefined;
1135
- readonly merge_commit_title?: "MERGE_MESSAGE" | "PR_TITLE" | undefined;
1136
- readonly merge_commit_message?: "BLANK" | "PR_BODY" | "PR_TITLE" | undefined;
1137
- readonly delete_branch_on_merge?: boolean | undefined;
1138
- readonly web_commit_signoff_required?: boolean | undefined;
1139
- readonly security_and_analysis?: {
1140
- readonly advanced_security?: "disabled" | "enabled" | undefined;
1141
- readonly code_security?: "disabled" | "enabled" | undefined;
1142
- readonly secret_scanning?: "disabled" | "enabled" | undefined;
1143
- readonly secret_scanning_push_protection?: "disabled" | "enabled" | undefined;
1144
- readonly secret_scanning_ai_detection?: "disabled" | "enabled" | undefined;
1145
- readonly secret_scanning_non_provider_patterns?: "disabled" | "enabled" | undefined;
1146
- readonly secret_scanning_delegated_alert_dismissal?: "disabled" | "enabled" | undefined;
1147
- readonly secret_scanning_delegated_bypass?: "disabled" | "enabled" | undefined;
1148
- readonly delegated_bypass_reviewers?: readonly ({
1149
- readonly team: string;
1150
- readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1151
- } | {
1152
- readonly role: string;
1153
- readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1154
- })[] | undefined;
1155
- readonly dependabot_security_updates?: "disabled" | "enabled" | undefined;
1156
- } | undefined;
1157
- };
1158
- };
1159
- readonly secrets: {
1160
- readonly [x: string]: {
1161
- readonly file: {
1162
- readonly [x: string]: string;
1163
- };
1164
- } | {
1165
- readonly value: {
1166
- readonly [x: string]: string | {
1167
- readonly [x: string]: unknown;
1168
- };
1169
- };
1170
- } | {
1171
- readonly resolved: {
1172
- readonly [x: string]: string;
1173
- };
1174
- };
1175
- };
1176
- readonly variables: {
1177
- readonly [x: string]: {
1178
- readonly file: {
1179
- readonly [x: string]: string;
1180
- };
1181
- } | {
1182
- readonly value: {
1183
- readonly [x: string]: string | {
1184
- readonly [x: string]: unknown;
1185
- };
1186
- };
1187
- } | {
1188
- readonly resolved: {
1189
- readonly [x: string]: string;
1190
- };
1191
- };
1192
- };
1193
- readonly rulesets: {
1194
- readonly [x: string]: {
1195
- readonly name: string;
1196
- readonly enforcement: "active" | "disabled" | "evaluate";
1197
- readonly conditions?: {
1198
- readonly ref_name?: {
1199
- readonly include: readonly string[];
1200
- readonly exclude: readonly string[];
1201
- } | undefined;
1202
- } | undefined;
1203
- readonly bypass_actors?: readonly {
1204
- readonly actor_id?: number | {
1205
- readonly resolved: string;
1206
- } | undefined;
1207
- readonly actor_type: "DeployKey" | "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team";
1208
- readonly bypass_mode: "always" | "exempt" | "pull_request";
1209
- }[] | undefined;
1210
- readonly creation?: boolean | undefined;
1211
- readonly update?: boolean | undefined;
1212
- readonly deletion?: boolean | undefined;
1213
- readonly required_linear_history?: boolean | undefined;
1214
- readonly required_signatures?: boolean | undefined;
1215
- readonly non_fast_forward?: boolean | undefined;
1216
- readonly deployments?: readonly string[] | undefined;
1217
- readonly targets?: "all" | "default" | readonly ({
1218
- readonly include: string;
1219
- } | {
1220
- readonly exclude: string;
1221
- })[] | undefined;
1222
- readonly status_checks?: {
1223
- readonly update_branch?: boolean | undefined;
1224
- readonly on_creation?: boolean | undefined;
1225
- readonly default_integration_id?: number | {
1226
- readonly resolved: string;
1227
- } | undefined;
1228
- readonly required: readonly {
1229
- readonly context: string;
1230
- readonly integration_id?: number | {
1231
- readonly resolved: string;
1232
- } | undefined;
1233
- }[];
1234
- } | undefined;
1235
- readonly commit_message?: readonly {
1236
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1237
- readonly pattern: string;
1238
- readonly name?: string | undefined;
1239
- readonly negate?: boolean | undefined;
1240
- }[] | undefined;
1241
- readonly commit_author_email?: readonly {
1242
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1243
- readonly pattern: string;
1244
- readonly name?: string | undefined;
1245
- readonly negate?: boolean | undefined;
1246
- }[] | undefined;
1247
- readonly committer_email?: readonly {
1248
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1249
- readonly pattern: string;
1250
- readonly name?: string | undefined;
1251
- readonly negate?: boolean | undefined;
1252
- }[] | undefined;
1253
- readonly type: "branch";
1254
- readonly pull_requests?: {
1255
- readonly approvals: number;
1256
- readonly dismiss_stale_reviews: boolean;
1257
- readonly code_owner_review: boolean;
1258
- readonly last_push_approval: boolean;
1259
- readonly resolve_threads: boolean;
1260
- readonly merge_methods?: readonly ("merge" | "rebase" | "squash")[] | undefined;
1261
- readonly reviewers?: readonly {
1262
- readonly file_patterns: readonly string[];
1263
- readonly minimum_approvals: number;
1264
- readonly reviewer: {
1265
- readonly id: number;
1266
- readonly type: "Team";
1267
- };
1268
- }[] | undefined;
1269
- } | undefined;
1270
- readonly merge_queue?: {
1271
- readonly check_timeout: number;
1272
- readonly grouping: "ALLGREEN" | "HEADGREEN";
1273
- readonly max_build: number;
1274
- readonly max_merge: number;
1275
- readonly merge_method: "MERGE" | "REBASE" | "SQUASH";
1276
- readonly min_merge: number;
1277
- readonly min_wait: number;
1278
- } | undefined;
1279
- readonly copilot_review?: {
1280
- readonly draft_prs?: boolean | undefined;
1281
- readonly on_push?: boolean | undefined;
1282
- } | undefined;
1283
- readonly code_scanning?: readonly {
1284
- readonly tool: string;
1285
- readonly alerts: "all" | "errors" | "errors_and_warnings" | "none";
1286
- readonly security_alerts: "all" | "critical" | "high_or_higher" | "medium_or_higher" | "none";
1287
- }[] | undefined;
1288
- readonly workflows?: {
1289
- readonly on_creation?: boolean | undefined;
1290
- readonly required: readonly {
1291
- readonly path: string;
1292
- readonly ref?: string | undefined;
1293
- readonly repository_id: number | {
1294
- readonly resolved: string;
1295
- };
1296
- readonly sha?: string | undefined;
1297
- }[];
1298
- } | undefined;
1299
- readonly branch_name?: readonly {
1300
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1301
- readonly pattern: string;
1302
- readonly name?: string | undefined;
1303
- readonly negate?: boolean | undefined;
1304
- }[] | undefined;
1305
- } | {
1306
- readonly name: string;
1307
- readonly enforcement: "active" | "disabled" | "evaluate";
1308
- readonly conditions?: {
1309
- readonly ref_name?: {
1310
- readonly include: readonly string[];
1311
- readonly exclude: readonly string[];
1312
- } | undefined;
1313
- } | undefined;
1314
- readonly bypass_actors?: readonly {
1315
- readonly actor_id?: number | {
1316
- readonly resolved: string;
1317
- } | undefined;
1318
- readonly actor_type: "DeployKey" | "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team";
1319
- readonly bypass_mode: "always" | "exempt" | "pull_request";
1320
- }[] | undefined;
1321
- readonly creation?: boolean | undefined;
1322
- readonly update?: boolean | undefined;
1323
- readonly deletion?: boolean | undefined;
1324
- readonly required_linear_history?: boolean | undefined;
1325
- readonly required_signatures?: boolean | undefined;
1326
- readonly non_fast_forward?: boolean | undefined;
1327
- readonly deployments?: readonly string[] | undefined;
1328
- readonly targets?: "all" | "default" | readonly ({
1329
- readonly include: string;
1330
- } | {
1331
- readonly exclude: string;
1332
- })[] | undefined;
1333
- readonly status_checks?: {
1334
- readonly update_branch?: boolean | undefined;
1335
- readonly on_creation?: boolean | undefined;
1336
- readonly default_integration_id?: number | {
1337
- readonly resolved: string;
1338
- } | undefined;
1339
- readonly required: readonly {
1340
- readonly context: string;
1341
- readonly integration_id?: number | {
1342
- readonly resolved: string;
1343
- } | undefined;
1344
- }[];
1345
- } | undefined;
1346
- readonly commit_message?: readonly {
1347
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1348
- readonly pattern: string;
1349
- readonly name?: string | undefined;
1350
- readonly negate?: boolean | undefined;
1351
- }[] | undefined;
1352
- readonly commit_author_email?: readonly {
1353
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1354
- readonly pattern: string;
1355
- readonly name?: string | undefined;
1356
- readonly negate?: boolean | undefined;
1357
- }[] | undefined;
1358
- readonly committer_email?: readonly {
1359
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1360
- readonly pattern: string;
1361
- readonly name?: string | undefined;
1362
- readonly negate?: boolean | undefined;
1363
- }[] | undefined;
1364
- readonly type: "tag";
1365
- readonly tag_name?: readonly {
1366
- readonly operator: "contains" | "ends_with" | "regex" | "starts_with";
1367
- readonly pattern: string;
1368
- readonly name?: string | undefined;
1369
- readonly negate?: boolean | undefined;
1370
- }[] | undefined;
1371
- };
1372
- };
1373
- readonly environments: {
1374
- readonly [x: string]: {
1375
- readonly wait_timer?: number | undefined;
1376
- readonly prevent_self_review?: boolean | undefined;
1377
- readonly reviewers?: readonly {
1378
- readonly type: "Team" | "User";
1379
- readonly id: number;
1380
- }[] | undefined;
1381
- readonly deployment_branches?: "all" | "protected" | readonly {
1382
- readonly name: string;
1383
- readonly type: "branch" | "tag";
1384
- }[] | undefined;
1385
- };
1386
- };
1387
- readonly security: {
1388
- readonly [x: string]: {
1389
- readonly vulnerability_alerts?: boolean | undefined;
1390
- readonly automated_security_fixes?: boolean | undefined;
1391
- readonly private_vulnerability_reporting?: boolean | undefined;
1392
- };
1393
- };
1394
- readonly code_scanning: {
1395
- readonly [x: string]: {
1396
- readonly state?: "configured" | "not-configured" | undefined;
1397
- readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
1398
- readonly query_suite?: "default" | "extended" | undefined;
1399
- readonly threat_model?: "remote" | "remote_and_local" | undefined;
1400
- readonly runner_type?: "labeled" | "standard" | undefined;
1401
- readonly runner_label?: string | undefined;
1402
- };
1403
- };
1404
- readonly groups: {
1405
- readonly [x: string]: {
1406
- readonly owner?: string | undefined;
1407
- readonly repos: readonly string[];
1408
- readonly credentials?: string | undefined;
1409
- readonly settings?: readonly string[] | undefined;
1410
- readonly environments?: readonly string[] | undefined;
1411
- readonly secrets?: {
1412
- readonly actions?: readonly string[] | undefined;
1413
- readonly dependabot?: readonly string[] | undefined;
1414
- readonly codespaces?: readonly string[] | undefined;
1415
- readonly environments?: {
1416
- readonly [x: string]: readonly string[];
1417
- } | undefined;
1418
- } | undefined;
1419
- readonly variables?: {
1420
- readonly actions?: readonly string[] | undefined;
1421
- readonly environments?: {
1422
- readonly [x: string]: readonly string[];
1423
- } | undefined;
1424
- } | undefined;
1425
- readonly rulesets?: readonly string[] | undefined;
1426
- readonly security?: readonly string[] | undefined;
1427
- readonly code_scanning?: readonly string[] | undefined;
1428
- readonly cleanup?: {
1429
- readonly secrets: {
1430
- readonly actions: boolean | {
1431
- readonly preserve: readonly string[];
1432
- };
1433
- readonly dependabot: boolean | {
1434
- readonly preserve: readonly string[];
1435
- };
1436
- readonly codespaces: boolean | {
1437
- readonly preserve: readonly string[];
1438
- };
1439
- readonly environments: boolean | {
1440
- readonly preserve: readonly string[];
1441
- };
1442
- };
1443
- readonly variables: {
1444
- readonly actions: boolean | {
1445
- readonly preserve: readonly string[];
1446
- };
1447
- readonly environments: boolean | {
1448
- readonly preserve: readonly string[];
1449
- };
1450
- };
1451
- readonly rulesets: boolean | {
1452
- readonly preserve: readonly string[];
1453
- };
1454
- readonly environments: boolean | {
1455
- readonly preserve: readonly string[];
1456
- };
1457
- } | undefined;
1458
- };
1459
- };
1460
- }>>;
1461
-
1462
- export declare const ReposetsCredentialsFile: Tag<ConfigFileService< {
1463
- readonly profiles: {
1464
- readonly [x: string]: {
1465
- readonly github_token: string;
1466
- readonly op_service_account_token?: string | undefined;
1467
- readonly resolve?: {
1468
- readonly op?: {
1469
- readonly [x: string]: string;
1470
- } | undefined;
1471
- readonly file?: {
1472
- readonly [x: string]: string;
1473
- } | undefined;
1474
- readonly value?: {
1475
- readonly [x: string]: string | {
1476
- readonly [x: string]: unknown;
1477
- };
1478
- } | undefined;
1479
- } | undefined;
1480
- };
1481
- };
1482
- }>, ConfigFileService< {
1483
- readonly profiles: {
1484
- readonly [x: string]: {
1485
- readonly github_token: string;
1486
- readonly op_service_account_token?: string | undefined;
1487
- readonly resolve?: {
1488
- readonly op?: {
1489
- readonly [x: string]: string;
1490
- } | undefined;
1491
- readonly file?: {
1492
- readonly [x: string]: string;
1493
- } | undefined;
1494
- readonly value?: {
1495
- readonly [x: string]: string | {
1496
- readonly [x: string]: unknown;
1497
- };
1498
- } | undefined;
1499
- } | undefined;
1500
- };
1501
- };
1502
- }>>;
1503
-
1504
- export declare type ResolvedRef = typeof ResolvedRefSchema.Type;
1505
-
1506
- export declare const ResolvedRefSchema: Schema.Struct<{
1507
- resolved: Schema.SchemaClass<string, string, never>;
1508
- }>;
1509
-
1510
- export declare class ResolveError extends ResolveError_base<{
1511
- readonly message: string;
1512
- }> {
1513
- }
1514
-
1515
- declare const ResolveError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty< { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
1516
- readonly _tag: "ResolveError";
1517
- } & Readonly<A>;
1518
-
1519
- export declare type ResolveSection = typeof ResolveSectionSchema.Type;
1520
-
1521
- export declare const ResolveSectionSchema: Schema.Struct<{
1522
- op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
1523
- file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
1524
- value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
1525
- }>;
1526
-
1527
- export declare type Ruleset = typeof RulesetSchema.Type;
1528
-
1529
- declare interface RulesetInfo {
1530
- name: string;
1531
- id: number;
1532
- source_type?: string | undefined;
1533
- }
1534
-
1535
- /** API-compatible payload for creating/updating a ruleset. */
1536
- export declare interface RulesetPayload {
1537
- name: string;
1538
- target: "branch" | "tag";
1539
- enforcement: "disabled" | "active" | "evaluate";
1540
- conditions?: Record<string, unknown>;
1541
- bypass_actors?: ReadonlyArray<Record<string, unknown>>;
1542
- rules?: ReadonlyArray<Record<string, unknown>>;
1543
- }
1544
-
1545
- export declare const RulesetSchema: Schema.Union<[Schema.Struct<{
1546
- name: Schema.SchemaClass<string, string, never>;
1547
- enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
1548
- conditions: Schema.optional<Schema.Struct<{
1549
- ref_name: Schema.optional<Schema.Struct<{
1550
- include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
1551
- default: () => never[];
1552
- }>;
1553
- exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
1554
- default: () => never[];
1555
- }>;
1556
- }>>;
1557
- }>>;
1558
- bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
1559
- actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1560
- resolved: Schema.SchemaClass<string, string, never>;
1561
- }>]>>;
1562
- actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
1563
- bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
1564
- default: () => "always";
1565
- }>;
1566
- }>>>;
1567
- creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1568
- update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1569
- deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1570
- required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1571
- required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1572
- non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1573
- deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
1574
- targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
1575
- include: Schema.SchemaClass<string, string, never>;
1576
- }>, Schema.Struct<{
1577
- exclude: Schema.SchemaClass<string, string, never>;
1578
- }>]>>]>>;
1579
- status_checks: Schema.optional<Schema.Struct<{
1580
- update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1581
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1582
- default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1583
- resolved: Schema.SchemaClass<string, string, never>;
1584
- }>]>>;
1585
- required: Schema.Array$<Schema.Struct<{
1586
- context: Schema.SchemaClass<string, string, never>;
1587
- integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1588
- resolved: Schema.SchemaClass<string, string, never>;
1589
- }>]>>;
1590
- }>>;
1591
- }>>;
1592
- commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
1593
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1594
- pattern: Schema.SchemaClass<string, string, never>;
1595
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1596
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1597
- }>>>;
1598
- commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
1599
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1600
- pattern: Schema.SchemaClass<string, string, never>;
1601
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1602
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1603
- }>>>;
1604
- committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
1605
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1606
- pattern: Schema.SchemaClass<string, string, never>;
1607
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1608
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1609
- }>>>;
1610
- type: Schema.Literal<["branch"]>;
1611
- pull_requests: Schema.optional<Schema.Struct<{
1612
- approvals: Schema.optionalWith<Schema.refine<number, typeof Schema.Int>, {
1613
- default: () => number;
1614
- }>;
1615
- dismiss_stale_reviews: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
1616
- default: () => boolean;
1617
- }>;
1618
- code_owner_review: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
1619
- default: () => boolean;
1620
- }>;
1621
- last_push_approval: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
1622
- default: () => boolean;
1623
- }>;
1624
- resolve_threads: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
1625
- default: () => boolean;
1626
- }>;
1627
- merge_methods: Schema.optional<Schema.Array$<Schema.Literal<["merge", "squash", "rebase"]>>>;
1628
- reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
1629
- file_patterns: Schema.Array$<typeof Schema.String>;
1630
- minimum_approvals: Schema.refine<number, typeof Schema.Number>;
1631
- reviewer: Schema.Struct<{
1632
- id: Schema.refine<number, typeof Schema.Number>;
1633
- type: Schema.Literal<["Team"]>;
1634
- }>;
1635
- }>>>;
1636
- }>>;
1637
- merge_queue: Schema.optional<Schema.Struct<{
1638
- check_timeout: Schema.refine<number, typeof Schema.Int>;
1639
- grouping: Schema.Literal<["ALLGREEN", "HEADGREEN"]>;
1640
- max_build: Schema.refine<number, typeof Schema.Int>;
1641
- max_merge: Schema.refine<number, typeof Schema.Int>;
1642
- merge_method: Schema.Literal<["MERGE", "SQUASH", "REBASE"]>;
1643
- min_merge: Schema.refine<number, typeof Schema.Int>;
1644
- min_wait: Schema.refine<number, typeof Schema.Int>;
1645
- }>>;
1646
- copilot_review: Schema.optional<Schema.Struct<{
1647
- draft_prs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1648
- on_push: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1649
- }>>;
1650
- code_scanning: Schema.optional<Schema.Array$<Schema.Struct<{
1651
- tool: Schema.SchemaClass<string, string, never>;
1652
- alerts: Schema.Literal<["none", "errors", "errors_and_warnings", "all"]>;
1653
- security_alerts: Schema.Literal<["none", "critical", "high_or_higher", "medium_or_higher", "all"]>;
1654
- }>>>;
1655
- workflows: Schema.optional<Schema.Struct<{
1656
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1657
- required: Schema.Array$<Schema.Struct<{
1658
- path: Schema.SchemaClass<string, string, never>;
1659
- ref: Schema.optional<Schema.SchemaClass<string, string, never>>;
1660
- repository_id: Schema.Union<[typeof Schema.Int, Schema.Struct<{
1661
- resolved: Schema.SchemaClass<string, string, never>;
1662
- }>]>;
1663
- sha: Schema.optional<Schema.SchemaClass<string, string, never>>;
1664
- }>>;
1665
- }>>;
1666
- branch_name: Schema.optional<Schema.Array$<Schema.Struct<{
1667
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1668
- pattern: Schema.SchemaClass<string, string, never>;
1669
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1670
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1671
- }>>>;
1672
- }>, Schema.Struct<{
1673
- name: Schema.SchemaClass<string, string, never>;
1674
- enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
1675
- conditions: Schema.optional<Schema.Struct<{
1676
- ref_name: Schema.optional<Schema.Struct<{
1677
- include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
1678
- default: () => never[];
1679
- }>;
1680
- exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
1681
- default: () => never[];
1682
- }>;
1683
- }>>;
1684
- }>>;
1685
- bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
1686
- actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1687
- resolved: Schema.SchemaClass<string, string, never>;
1688
- }>]>>;
1689
- actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
1690
- bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
1691
- default: () => "always";
1692
- }>;
1693
- }>>>;
1694
- creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1695
- update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1696
- deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1697
- required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1698
- required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1699
- non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1700
- deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
1701
- targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
1702
- include: Schema.SchemaClass<string, string, never>;
1703
- }>, Schema.Struct<{
1704
- exclude: Schema.SchemaClass<string, string, never>;
1705
- }>]>>]>>;
1706
- status_checks: Schema.optional<Schema.Struct<{
1707
- update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1708
- on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1709
- default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1710
- resolved: Schema.SchemaClass<string, string, never>;
1711
- }>]>>;
1712
- required: Schema.Array$<Schema.Struct<{
1713
- context: Schema.SchemaClass<string, string, never>;
1714
- integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
1715
- resolved: Schema.SchemaClass<string, string, never>;
1716
- }>]>>;
1717
- }>>;
1718
- }>>;
1719
- commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
1720
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1721
- pattern: Schema.SchemaClass<string, string, never>;
1722
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1723
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1724
- }>>>;
1725
- commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
1726
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1727
- pattern: Schema.SchemaClass<string, string, never>;
1728
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1729
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1730
- }>>>;
1731
- committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
1732
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1733
- pattern: Schema.SchemaClass<string, string, never>;
1734
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1735
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1736
- }>>>;
1737
- type: Schema.Literal<["tag"]>;
1738
- tag_name: Schema.optional<Schema.Array$<Schema.Struct<{
1739
- operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
1740
- pattern: Schema.SchemaClass<string, string, never>;
1741
- name: Schema.optional<Schema.SchemaClass<string, string, never>>;
1742
- negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
1743
- }>>>;
1744
- }>]>;
1745
-
1746
- export declare type SecretGroup = typeof SecretGroupSchema.Type;
1747
-
1748
- export declare const SecretGroupSchema: Schema.Union<[Schema.Struct<{
1749
- file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
1750
- }>, Schema.Struct<{
1751
- value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
1752
- }>, Schema.Struct<{
1753
- resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
1754
- }>]>;
1755
-
1756
- declare interface SecretInfo {
1757
- name: string;
1758
- }
1759
-
1760
- declare type SecretScope = "actions" | "dependabot" | "codespaces";
1761
-
1762
- export declare class SyncEngine extends SyncEngine_base {
1763
- }
1764
-
1765
- declare const SyncEngine_base: Context.TagClass<SyncEngine, "SyncEngine", SyncEngineService>;
1766
-
1767
- export declare const SyncEngineLive: Layer_2.Layer<SyncEngine, never, CredentialResolver | GitHubClient | SyncLogger>;
1768
-
1769
- declare interface SyncEngineService {
1770
- readonly syncAll: (config: Config, credentials: Credentials, options: SyncOptions) => Effect.Effect<void, SyncError>;
1771
- }
1772
-
1773
- export declare class SyncError extends SyncError_base<{
1774
- readonly message: string;
1775
- }> {
1776
- }
1777
-
1778
- declare const SyncError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty< { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
1779
- readonly _tag: "SyncError";
1780
- } & Readonly<A>;
1781
-
1782
- export declare class SyncLogger extends SyncLogger_base {
1783
- }
1784
-
1785
- declare const SyncLogger_base: Context.TagClass<SyncLogger, "SyncLogger", SyncLoggerService>;
1786
-
1787
- export declare interface SyncLoggerConfig {
1788
- readonly dryRun: boolean;
1789
- readonly logLevel: LogLevel;
1790
- readonly output?: Ref.Ref<string[]>;
1791
- }
1792
-
1793
- export declare function SyncLoggerLive(config: SyncLoggerConfig): Layer_2.Layer<SyncLogger>;
1794
-
1795
- declare interface SyncLoggerService {
1796
- readonly groupStart: (name: string, repoCount: number) => Effect.Effect<void>;
1797
- readonly repoStart: (owner: string, repo: string) => Effect.Effect<void>;
1798
- readonly repoSkip: (owner: string, repo: string, reason: string) => Effect.Effect<void>;
1799
- readonly syncSummary: (resource: "secret" | "variable" | "ruleset" | "environment" | "security feature" | "code scanning", count: number, detail: string) => Effect.Effect<void>;
1800
- readonly settingsApplied: () => Effect.Effect<void>;
1801
- readonly cleanupSummary: (resource: string, count: number, names: string[]) => Effect.Effect<void>;
1802
- readonly syncOperation: (verb: "sync" | "apply" | "delete" | "skip", resource: string, name: string, detail?: string, source?: string) => Effect.Effect<void>;
1803
- readonly syncError: (context: string, message: string) => Effect.Effect<void>;
1804
- readonly finish: () => Effect.Effect<void>;
1805
- }
1806
-
1807
- declare interface SyncOptions {
1808
- readonly dryRun: boolean;
1809
- readonly noCleanup: boolean;
1810
- readonly groupFilter?: string | undefined;
1811
- readonly repoFilter?: string | undefined;
1812
- readonly configDir: string;
1813
- }
1814
-
1815
- /**
1816
- * Validates all internal cross-references in a parsed config. Checks that
1817
- * every group's settings, secrets, variables, rulesets, and environments
1818
- * references point to defined top-level sections, and that environment-scoped
1819
- * secret/variable groups reference defined environments. Collects ALL errors
1820
- * into a single ConfigError.
1821
- */
1822
- export declare function validateConfigRefs(config: Config): Effect.Effect<Config, XdgConfigError>;
1823
-
1824
- export declare type VariableGroup = typeof VariableGroupSchema.Type;
1825
-
1826
- export declare const VariableGroupSchema: Schema.Union<[Schema.Struct<{
1827
- file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
1828
- }>, Schema.Struct<{
1829
- value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
1830
- }>, Schema.Struct<{
1831
- resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
1832
- }>]>;
1833
-
1834
- declare interface VariableInfo {
1835
- name: string;
1836
- }
1837
-
1838
- export { XdgConfigError }
1839
-
1840
- export { }
1
+ import { AppDirs, ConfigError, ConfigError as XdgConfigError, ConfigFile } from "xdg-effect";
2
+ import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
3
+
4
+ //#region src/errors.d.ts
5
+ declare const ResolveError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
6
+ readonly _tag: "ResolveError";
7
+ } & Readonly<A>;
8
+ declare class ResolveError extends ResolveError_base<{
9
+ readonly message: string;
10
+ }> {}
11
+ declare const OnePasswordError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
12
+ readonly _tag: "OnePasswordError";
13
+ } & Readonly<A>;
14
+ declare class OnePasswordError extends OnePasswordError_base<{
15
+ readonly message: string;
16
+ }> {}
17
+ declare const GitHubApiError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
18
+ readonly _tag: "GitHubApiError";
19
+ } & Readonly<A>;
20
+ declare class GitHubApiError extends GitHubApiError_base<{
21
+ readonly message: string;
22
+ readonly status?: number;
23
+ }> {}
24
+ declare const SyncError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
25
+ readonly _tag: "SyncError";
26
+ } & Readonly<A>;
27
+ declare class SyncError extends SyncError_base<{
28
+ readonly message: string;
29
+ }> {}
30
+ //#endregion
31
+ //#region src/lib/crypto.d.ts
32
+ /**
33
+ * Encrypt a secret using libsodium's sealed box algorithm.
34
+ * Implementation based on tweetsodium using tweetnacl + blakejs.
35
+ *
36
+ * The sealed box format is: ephemeral_public_key (32 bytes) || ciphertext
37
+ */
38
+ declare function encryptSecret(publicKey: string, secretValue: string): string;
39
+ //#endregion
40
+ //#region src/schemas/common.d.ts
41
+ declare const SecretGroupSchema: Schema.Union<[Schema.Struct<{
42
+ file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
43
+ }>, Schema.Struct<{
44
+ value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
45
+ }>, Schema.Struct<{
46
+ resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
47
+ }>]>;
48
+ type SecretGroup = typeof SecretGroupSchema.Type;
49
+ declare const VariableGroupSchema: Schema.Union<[Schema.Struct<{
50
+ file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
51
+ }>, Schema.Struct<{
52
+ value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
53
+ }>, Schema.Struct<{
54
+ resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
55
+ }>]>;
56
+ type VariableGroup = typeof VariableGroupSchema.Type;
57
+ declare const CleanupScopeSchema: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
58
+ preserve: Schema.Array$<typeof Schema.String>;
59
+ }>]>;
60
+ type CleanupScope = typeof CleanupScopeSchema.Type;
61
+ declare const CleanupSchema: Schema.Struct<{
62
+ secrets: Schema.optionalWith<Schema.Struct<{
63
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
64
+ preserve: Schema.Array$<typeof Schema.String>;
65
+ }>]>, {
66
+ default: () => CleanupScope;
67
+ }>;
68
+ dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
69
+ preserve: Schema.Array$<typeof Schema.String>;
70
+ }>]>, {
71
+ default: () => CleanupScope;
72
+ }>;
73
+ codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
74
+ preserve: Schema.Array$<typeof Schema.String>;
75
+ }>]>, {
76
+ default: () => CleanupScope;
77
+ }>;
78
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
79
+ preserve: Schema.Array$<typeof Schema.String>;
80
+ }>]>, {
81
+ default: () => CleanupScope;
82
+ }>;
83
+ }>, {
84
+ default: () => {
85
+ actions: CleanupScope;
86
+ dependabot: CleanupScope;
87
+ codespaces: CleanupScope;
88
+ environments: CleanupScope;
89
+ };
90
+ }>;
91
+ variables: Schema.optionalWith<Schema.Struct<{
92
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
93
+ preserve: Schema.Array$<typeof Schema.String>;
94
+ }>]>, {
95
+ default: () => CleanupScope;
96
+ }>;
97
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
98
+ preserve: Schema.Array$<typeof Schema.String>;
99
+ }>]>, {
100
+ default: () => CleanupScope;
101
+ }>;
102
+ }>, {
103
+ default: () => {
104
+ actions: CleanupScope;
105
+ environments: CleanupScope;
106
+ };
107
+ }>;
108
+ rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
109
+ preserve: Schema.Array$<typeof Schema.String>;
110
+ }>]>, {
111
+ default: () => CleanupScope;
112
+ }>;
113
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
114
+ preserve: Schema.Array$<typeof Schema.String>;
115
+ }>]>, {
116
+ default: () => CleanupScope;
117
+ }>;
118
+ }>;
119
+ type Cleanup = typeof CleanupSchema.Type;
120
+ //#endregion
121
+ //#region src/schemas/config.d.ts
122
+ declare const GroupSchema: Schema.Struct<{
123
+ owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
124
+ repos: Schema.Array$<typeof Schema.String>;
125
+ credentials: Schema.optional<Schema.SchemaClass<string, string, never>>;
126
+ settings: Schema.optional<Schema.Array$<typeof Schema.String>>;
127
+ environments: Schema.optional<Schema.Array$<typeof Schema.String>>;
128
+ secrets: Schema.optional<Schema.Struct<{
129
+ actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
130
+ dependabot: Schema.optional<Schema.Array$<typeof Schema.String>>;
131
+ codespaces: Schema.optional<Schema.Array$<typeof Schema.String>>;
132
+ environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
133
+ }>>;
134
+ variables: Schema.optional<Schema.Struct<{
135
+ actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
136
+ environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
137
+ }>>;
138
+ rulesets: Schema.optional<Schema.Array$<typeof Schema.String>>;
139
+ security: Schema.optional<Schema.Array$<typeof Schema.String>>;
140
+ code_scanning: Schema.optional<Schema.Array$<typeof Schema.String>>;
141
+ cleanup: Schema.optional<Schema.Struct<{
142
+ secrets: Schema.optionalWith<Schema.Struct<{
143
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
144
+ preserve: Schema.Array$<typeof Schema.String>;
145
+ }>]>, {
146
+ default: () => CleanupScope;
147
+ }>;
148
+ dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
149
+ preserve: Schema.Array$<typeof Schema.String>;
150
+ }>]>, {
151
+ default: () => CleanupScope;
152
+ }>;
153
+ codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
154
+ preserve: Schema.Array$<typeof Schema.String>;
155
+ }>]>, {
156
+ default: () => CleanupScope;
157
+ }>;
158
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
159
+ preserve: Schema.Array$<typeof Schema.String>;
160
+ }>]>, {
161
+ default: () => CleanupScope;
162
+ }>;
163
+ }>, {
164
+ default: () => {
165
+ actions: CleanupScope;
166
+ dependabot: CleanupScope;
167
+ codespaces: CleanupScope;
168
+ environments: CleanupScope;
169
+ };
170
+ }>;
171
+ variables: Schema.optionalWith<Schema.Struct<{
172
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
173
+ preserve: Schema.Array$<typeof Schema.String>;
174
+ }>]>, {
175
+ default: () => CleanupScope;
176
+ }>;
177
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
178
+ preserve: Schema.Array$<typeof Schema.String>;
179
+ }>]>, {
180
+ default: () => CleanupScope;
181
+ }>;
182
+ }>, {
183
+ default: () => {
184
+ actions: CleanupScope;
185
+ environments: CleanupScope;
186
+ };
187
+ }>;
188
+ rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
189
+ preserve: Schema.Array$<typeof Schema.String>;
190
+ }>]>, {
191
+ default: () => CleanupScope;
192
+ }>;
193
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
194
+ preserve: Schema.Array$<typeof Schema.String>;
195
+ }>]>, {
196
+ default: () => CleanupScope;
197
+ }>;
198
+ }>>;
199
+ }>;
200
+ type Group = typeof GroupSchema.Type;
201
+ declare const CodeScanningGroupSchema: Schema.refine<{
202
+ readonly state?: "configured" | "not-configured" | undefined;
203
+ readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
204
+ readonly query_suite?: "default" | "extended" | undefined;
205
+ readonly threat_model?: "remote" | "remote_and_local" | undefined;
206
+ readonly runner_type?: "standard" | "labeled" | undefined;
207
+ readonly runner_label?: string | undefined;
208
+ }, Schema.Struct<{
209
+ state: Schema.optional<Schema.Literal<["configured", "not-configured"]>>;
210
+ languages: Schema.optional<Schema.Array$<Schema.Literal<["actions", "c-cpp", "csharp", "go", "java-kotlin", "javascript-typescript", "python", "ruby", "swift"]>>>;
211
+ query_suite: Schema.optional<Schema.Literal<["default", "extended"]>>;
212
+ threat_model: Schema.optional<Schema.Literal<["remote", "remote_and_local"]>>;
213
+ runner_type: Schema.optional<Schema.Literal<["standard", "labeled"]>>;
214
+ runner_label: Schema.optional<Schema.SchemaClass<string, string, never>>;
215
+ }>>;
216
+ type CodeScanningGroup = typeof CodeScanningGroupSchema.Type;
217
+ declare const LogLevelSchema: Schema.Literal<["silent", "info", "verbose", "debug"]>;
218
+ type LogLevel = typeof LogLevelSchema.Type;
219
+ declare const ConfigSchema: Schema.Struct<{
220
+ owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
221
+ log_level: Schema.optionalWith<Schema.Literal<["silent", "info", "verbose", "debug"]>, {
222
+ default: () => "info";
223
+ }>;
224
+ settings: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.TypeLiteral<{
225
+ is_template: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
226
+ has_wiki: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
227
+ has_issues: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
228
+ has_projects: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
229
+ has_discussions: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
230
+ has_sponsorships: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
231
+ has_pull_requests: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
232
+ allow_forking: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
233
+ allow_merge_commit: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
234
+ allow_squash_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
235
+ allow_rebase_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
236
+ allow_auto_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
237
+ allow_update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
238
+ squash_merge_commit_title: Schema.optional<Schema.Literal<["PR_TITLE", "COMMIT_OR_PR_TITLE"]>>;
239
+ squash_merge_commit_message: Schema.optional<Schema.Literal<["PR_BODY", "COMMIT_MESSAGES", "BLANK"]>>;
240
+ merge_commit_title: Schema.optional<Schema.Literal<["PR_TITLE", "MERGE_MESSAGE"]>>;
241
+ merge_commit_message: Schema.optional<Schema.Literal<["PR_BODY", "PR_TITLE", "BLANK"]>>;
242
+ delete_branch_on_merge: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
243
+ web_commit_signoff_required: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
244
+ security_and_analysis: Schema.optional<Schema.Struct<{
245
+ advanced_security: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
246
+ code_security: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
247
+ secret_scanning: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
248
+ secret_scanning_push_protection: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
249
+ secret_scanning_ai_detection: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
250
+ secret_scanning_non_provider_patterns: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
251
+ secret_scanning_delegated_alert_dismissal: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
252
+ secret_scanning_delegated_bypass: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
253
+ delegated_bypass_reviewers: Schema.optional<Schema.Array$<Schema.Union<[Schema.Struct<{
254
+ team: Schema.SchemaClass<string, string, never>;
255
+ mode: Schema.optional<Schema.Literal<["ALWAYS", "EXEMPT"]>>;
256
+ }>, Schema.Struct<{
257
+ role: Schema.SchemaClass<string, string, never>;
258
+ mode: Schema.optional<Schema.Literal<["ALWAYS", "EXEMPT"]>>;
259
+ }>]>>>;
260
+ dependabot_security_updates: Schema.optional<Schema.Literal<["enabled", "disabled"]>>;
261
+ }>>;
262
+ }, readonly [{
263
+ readonly key: typeof Schema.String;
264
+ readonly value: Schema.SchemaClass<unknown, unknown, never>;
265
+ }]>>, {
266
+ default: () => {};
267
+ }>;
268
+ secrets: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
269
+ file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
270
+ }>, Schema.Struct<{
271
+ value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
272
+ }>, Schema.Struct<{
273
+ resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
274
+ }>]>>, {
275
+ default: () => {};
276
+ }>;
277
+ variables: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
278
+ file: Schema.Record$<typeof Schema.String, typeof Schema.String>;
279
+ }>, Schema.Struct<{
280
+ value: Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>;
281
+ }>, Schema.Struct<{
282
+ resolved: Schema.Record$<typeof Schema.String, typeof Schema.String>;
283
+ }>]>>, {
284
+ default: () => {};
285
+ }>;
286
+ rulesets: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.Struct<{
287
+ type: Schema.Literal<["branch"]>;
288
+ pull_requests: Schema.optional<Schema.Struct<{
289
+ approvals: Schema.optionalWith<Schema.refine<number, typeof Schema.Int>, {
290
+ default: () => number;
291
+ }>;
292
+ dismiss_stale_reviews: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
293
+ default: () => boolean;
294
+ }>;
295
+ code_owner_review: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
296
+ default: () => boolean;
297
+ }>;
298
+ last_push_approval: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
299
+ default: () => boolean;
300
+ }>;
301
+ resolve_threads: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
302
+ default: () => boolean;
303
+ }>;
304
+ merge_methods: Schema.optional<Schema.Array$<Schema.Literal<["merge", "squash", "rebase"]>>>;
305
+ reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
306
+ file_patterns: Schema.Array$<typeof Schema.String>;
307
+ minimum_approvals: Schema.refine<number, typeof Schema.Number>;
308
+ reviewer: Schema.Struct<{
309
+ id: Schema.refine<number, typeof Schema.Number>;
310
+ type: Schema.Literal<["Team"]>;
311
+ }>;
312
+ }>>>;
313
+ }>>;
314
+ merge_queue: Schema.optional<Schema.Struct<{
315
+ check_timeout: Schema.refine<number, typeof Schema.Int>;
316
+ grouping: Schema.Literal<["ALLGREEN", "HEADGREEN"]>;
317
+ max_build: Schema.refine<number, typeof Schema.Int>;
318
+ max_merge: Schema.refine<number, typeof Schema.Int>;
319
+ merge_method: Schema.Literal<["MERGE", "SQUASH", "REBASE"]>;
320
+ min_merge: Schema.refine<number, typeof Schema.Int>;
321
+ min_wait: Schema.refine<number, typeof Schema.Int>;
322
+ }>>;
323
+ copilot_review: Schema.optional<Schema.Struct<{
324
+ draft_prs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
325
+ on_push: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
326
+ }>>;
327
+ code_scanning: Schema.optional<Schema.Array$<Schema.Struct<{
328
+ tool: Schema.SchemaClass<string, string, never>;
329
+ alerts: Schema.Literal<["none", "errors", "errors_and_warnings", "all"]>;
330
+ security_alerts: Schema.Literal<["none", "critical", "high_or_higher", "medium_or_higher", "all"]>;
331
+ }>>>;
332
+ workflows: Schema.optional<Schema.Struct<{
333
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
334
+ required: Schema.Array$<Schema.Struct<{
335
+ path: Schema.SchemaClass<string, string, never>;
336
+ ref: Schema.optional<Schema.SchemaClass<string, string, never>>;
337
+ repository_id: Schema.Union<[typeof Schema.Int, Schema.Struct<{
338
+ resolved: Schema.SchemaClass<string, string, never>;
339
+ }>]>;
340
+ sha: Schema.optional<Schema.SchemaClass<string, string, never>>;
341
+ }>>;
342
+ }>>;
343
+ branch_name: Schema.optional<Schema.Array$<Schema.Struct<{
344
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
345
+ pattern: Schema.SchemaClass<string, string, never>;
346
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
347
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
348
+ }>>>;
349
+ name: Schema.SchemaClass<string, string, never>;
350
+ enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
351
+ conditions: Schema.optional<Schema.Struct<{
352
+ ref_name: Schema.optional<Schema.Struct<{
353
+ include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
354
+ default: () => never[];
355
+ }>;
356
+ exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
357
+ default: () => never[];
358
+ }>;
359
+ }>>;
360
+ }>>;
361
+ bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
362
+ actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
363
+ resolved: Schema.SchemaClass<string, string, never>;
364
+ }>]>>;
365
+ actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
366
+ bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
367
+ default: () => "always";
368
+ }>;
369
+ }>>>;
370
+ creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
371
+ update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
372
+ deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
373
+ required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
374
+ required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
375
+ non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
376
+ deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
377
+ targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
378
+ include: Schema.SchemaClass<string, string, never>;
379
+ }>, Schema.Struct<{
380
+ exclude: Schema.SchemaClass<string, string, never>;
381
+ }>]>>]>>;
382
+ status_checks: Schema.optional<Schema.Struct<{
383
+ update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
384
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
385
+ default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
386
+ resolved: Schema.SchemaClass<string, string, never>;
387
+ }>]>>;
388
+ required: Schema.Array$<Schema.Struct<{
389
+ context: Schema.SchemaClass<string, string, never>;
390
+ integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
391
+ resolved: Schema.SchemaClass<string, string, never>;
392
+ }>]>>;
393
+ }>>;
394
+ }>>;
395
+ commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
396
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
397
+ pattern: Schema.SchemaClass<string, string, never>;
398
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
399
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
400
+ }>>>;
401
+ commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
402
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
403
+ pattern: Schema.SchemaClass<string, string, never>;
404
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
405
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
406
+ }>>>;
407
+ committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
408
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
409
+ pattern: Schema.SchemaClass<string, string, never>;
410
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
411
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
412
+ }>>>;
413
+ }>, Schema.Struct<{
414
+ type: Schema.Literal<["tag"]>;
415
+ tag_name: Schema.optional<Schema.Array$<Schema.Struct<{
416
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
417
+ pattern: Schema.SchemaClass<string, string, never>;
418
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
419
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
420
+ }>>>;
421
+ name: Schema.SchemaClass<string, string, never>;
422
+ enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
423
+ conditions: Schema.optional<Schema.Struct<{
424
+ ref_name: Schema.optional<Schema.Struct<{
425
+ include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
426
+ default: () => never[];
427
+ }>;
428
+ exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
429
+ default: () => never[];
430
+ }>;
431
+ }>>;
432
+ }>>;
433
+ bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
434
+ actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
435
+ resolved: Schema.SchemaClass<string, string, never>;
436
+ }>]>>;
437
+ actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
438
+ bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
439
+ default: () => "always";
440
+ }>;
441
+ }>>>;
442
+ creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
443
+ update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
444
+ deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
445
+ required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
446
+ required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
447
+ non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
448
+ deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
449
+ targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
450
+ include: Schema.SchemaClass<string, string, never>;
451
+ }>, Schema.Struct<{
452
+ exclude: Schema.SchemaClass<string, string, never>;
453
+ }>]>>]>>;
454
+ status_checks: Schema.optional<Schema.Struct<{
455
+ update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
456
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
457
+ default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
458
+ resolved: Schema.SchemaClass<string, string, never>;
459
+ }>]>>;
460
+ required: Schema.Array$<Schema.Struct<{
461
+ context: Schema.SchemaClass<string, string, never>;
462
+ integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
463
+ resolved: Schema.SchemaClass<string, string, never>;
464
+ }>]>>;
465
+ }>>;
466
+ }>>;
467
+ commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
468
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
469
+ pattern: Schema.SchemaClass<string, string, never>;
470
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
471
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
472
+ }>>>;
473
+ commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
474
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
475
+ pattern: Schema.SchemaClass<string, string, never>;
476
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
477
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
478
+ }>>>;
479
+ committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
480
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
481
+ pattern: Schema.SchemaClass<string, string, never>;
482
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
483
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
484
+ }>>>;
485
+ }>]>>, {
486
+ default: () => {};
487
+ }>;
488
+ environments: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
489
+ wait_timer: Schema.optional<Schema.refine<number, typeof Schema.Int>>;
490
+ prevent_self_review: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
491
+ reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
492
+ type: Schema.Literal<["User", "Team"]>;
493
+ id: Schema.refine<number, typeof Schema.Number>;
494
+ }>>>;
495
+ deployment_branches: Schema.optional<Schema.Union<[Schema.Literal<["all", "protected"]>, Schema.Array$<Schema.Struct<{
496
+ name: Schema.SchemaClass<string, string, never>;
497
+ type: Schema.optionalWith<Schema.Literal<["branch", "tag"]>, {
498
+ default: () => "branch";
499
+ }>;
500
+ }>>]>>;
501
+ }>>, {
502
+ default: () => {};
503
+ }>;
504
+ security: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.refine<{
505
+ readonly vulnerability_alerts?: boolean | undefined;
506
+ readonly automated_security_fixes?: boolean | undefined;
507
+ readonly private_vulnerability_reporting?: boolean | undefined;
508
+ }, Schema.Struct<{
509
+ vulnerability_alerts: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
510
+ automated_security_fixes: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
511
+ private_vulnerability_reporting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
512
+ }>>>, {
513
+ default: () => {};
514
+ }>;
515
+ code_scanning: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.refine<{
516
+ readonly state?: "configured" | "not-configured" | undefined;
517
+ readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
518
+ readonly query_suite?: "default" | "extended" | undefined;
519
+ readonly threat_model?: "remote" | "remote_and_local" | undefined;
520
+ readonly runner_type?: "standard" | "labeled" | undefined;
521
+ readonly runner_label?: string | undefined;
522
+ }, Schema.Struct<{
523
+ state: Schema.optional<Schema.Literal<["configured", "not-configured"]>>;
524
+ languages: Schema.optional<Schema.Array$<Schema.Literal<["actions", "c-cpp", "csharp", "go", "java-kotlin", "javascript-typescript", "python", "ruby", "swift"]>>>;
525
+ query_suite: Schema.optional<Schema.Literal<["default", "extended"]>>;
526
+ threat_model: Schema.optional<Schema.Literal<["remote", "remote_and_local"]>>;
527
+ runner_type: Schema.optional<Schema.Literal<["standard", "labeled"]>>;
528
+ runner_label: Schema.optional<Schema.SchemaClass<string, string, never>>;
529
+ }>>>, {
530
+ default: () => {};
531
+ }>;
532
+ groups: Schema.Record$<typeof Schema.String, Schema.Struct<{
533
+ owner: Schema.optional<Schema.SchemaClass<string, string, never>>;
534
+ repos: Schema.Array$<typeof Schema.String>;
535
+ credentials: Schema.optional<Schema.SchemaClass<string, string, never>>;
536
+ settings: Schema.optional<Schema.Array$<typeof Schema.String>>;
537
+ environments: Schema.optional<Schema.Array$<typeof Schema.String>>;
538
+ secrets: Schema.optional<Schema.Struct<{
539
+ actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
540
+ dependabot: Schema.optional<Schema.Array$<typeof Schema.String>>;
541
+ codespaces: Schema.optional<Schema.Array$<typeof Schema.String>>;
542
+ environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
543
+ }>>;
544
+ variables: Schema.optional<Schema.Struct<{
545
+ actions: Schema.optional<Schema.Array$<typeof Schema.String>>;
546
+ environments: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
547
+ }>>;
548
+ rulesets: Schema.optional<Schema.Array$<typeof Schema.String>>;
549
+ security: Schema.optional<Schema.Array$<typeof Schema.String>>;
550
+ code_scanning: Schema.optional<Schema.Array$<typeof Schema.String>>;
551
+ cleanup: Schema.optional<Schema.Struct<{
552
+ secrets: Schema.optionalWith<Schema.Struct<{
553
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
554
+ preserve: Schema.Array$<typeof Schema.String>;
555
+ }>]>, {
556
+ default: () => CleanupScope;
557
+ }>;
558
+ dependabot: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
559
+ preserve: Schema.Array$<typeof Schema.String>;
560
+ }>]>, {
561
+ default: () => CleanupScope;
562
+ }>;
563
+ codespaces: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
564
+ preserve: Schema.Array$<typeof Schema.String>;
565
+ }>]>, {
566
+ default: () => CleanupScope;
567
+ }>;
568
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
569
+ preserve: Schema.Array$<typeof Schema.String>;
570
+ }>]>, {
571
+ default: () => CleanupScope;
572
+ }>;
573
+ }>, {
574
+ default: () => {
575
+ actions: CleanupScope;
576
+ dependabot: CleanupScope;
577
+ codespaces: CleanupScope;
578
+ environments: CleanupScope;
579
+ };
580
+ }>;
581
+ variables: Schema.optionalWith<Schema.Struct<{
582
+ actions: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
583
+ preserve: Schema.Array$<typeof Schema.String>;
584
+ }>]>, {
585
+ default: () => CleanupScope;
586
+ }>;
587
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
588
+ preserve: Schema.Array$<typeof Schema.String>;
589
+ }>]>, {
590
+ default: () => CleanupScope;
591
+ }>;
592
+ }>, {
593
+ default: () => {
594
+ actions: CleanupScope;
595
+ environments: CleanupScope;
596
+ };
597
+ }>;
598
+ rulesets: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
599
+ preserve: Schema.Array$<typeof Schema.String>;
600
+ }>]>, {
601
+ default: () => CleanupScope;
602
+ }>;
603
+ environments: Schema.optionalWith<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
604
+ preserve: Schema.Array$<typeof Schema.String>;
605
+ }>]>, {
606
+ default: () => CleanupScope;
607
+ }>;
608
+ }>>;
609
+ }>>;
610
+ }>;
611
+ type Config = typeof ConfigSchema.Type;
612
+ //#endregion
613
+ //#region src/schemas/credentials.d.ts
614
+ declare const ResolveSectionSchema: Schema.Struct<{
615
+ op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
616
+ file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
617
+ value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
618
+ }>;
619
+ type ResolveSection = typeof ResolveSectionSchema.Type;
620
+ declare const CredentialProfileSchema: Schema.Struct<{
621
+ github_token: Schema.SchemaClass<string, string, never>;
622
+ op_service_account_token: Schema.optional<Schema.SchemaClass<string, string, never>>;
623
+ resolve: Schema.optional<Schema.Struct<{
624
+ op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
625
+ file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
626
+ value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
627
+ }>>;
628
+ }>;
629
+ type CredentialProfile = typeof CredentialProfileSchema.Type;
630
+ declare const CredentialsSchema: Schema.Struct<{
631
+ profiles: Schema.optionalWith<Schema.Record$<typeof Schema.String, Schema.Struct<{
632
+ github_token: Schema.SchemaClass<string, string, never>;
633
+ op_service_account_token: Schema.optional<Schema.SchemaClass<string, string, never>>;
634
+ resolve: Schema.optional<Schema.Struct<{
635
+ op: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
636
+ file: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
637
+ value: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, Schema.Record$<typeof Schema.String, Schema.SchemaClass<unknown, unknown, never>>]>>>;
638
+ }>>;
639
+ }>>, {
640
+ default: () => {};
641
+ }>;
642
+ }>;
643
+ type Credentials = typeof CredentialsSchema.Type;
644
+ //#endregion
645
+ //#region src/schemas/ruleset.d.ts
646
+ declare const ResolvedRefSchema: Schema.Struct<{
647
+ resolved: Schema.SchemaClass<string, string, never>;
648
+ }>;
649
+ type ResolvedRef = typeof ResolvedRefSchema.Type;
650
+ declare const BypassActorSchema: Schema.Struct<{
651
+ actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
652
+ resolved: Schema.SchemaClass<string, string, never>;
653
+ }>]>>;
654
+ actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
655
+ bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
656
+ default: () => "always";
657
+ }>;
658
+ }>;
659
+ type BypassActor = typeof BypassActorSchema.Type;
660
+ declare const RulesetSchema: Schema.Union<[Schema.Struct<{
661
+ type: Schema.Literal<["branch"]>;
662
+ pull_requests: Schema.optional<Schema.Struct<{
663
+ approvals: Schema.optionalWith<Schema.refine<number, typeof Schema.Int>, {
664
+ default: () => number;
665
+ }>;
666
+ dismiss_stale_reviews: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
667
+ default: () => boolean;
668
+ }>;
669
+ code_owner_review: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
670
+ default: () => boolean;
671
+ }>;
672
+ last_push_approval: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
673
+ default: () => boolean;
674
+ }>;
675
+ resolve_threads: Schema.optionalWith<Schema.SchemaClass<boolean, boolean, never>, {
676
+ default: () => boolean;
677
+ }>;
678
+ merge_methods: Schema.optional<Schema.Array$<Schema.Literal<["merge", "squash", "rebase"]>>>;
679
+ reviewers: Schema.optional<Schema.Array$<Schema.Struct<{
680
+ file_patterns: Schema.Array$<typeof Schema.String>;
681
+ minimum_approvals: Schema.refine<number, typeof Schema.Number>;
682
+ reviewer: Schema.Struct<{
683
+ id: Schema.refine<number, typeof Schema.Number>;
684
+ type: Schema.Literal<["Team"]>;
685
+ }>;
686
+ }>>>;
687
+ }>>;
688
+ merge_queue: Schema.optional<Schema.Struct<{
689
+ check_timeout: Schema.refine<number, typeof Schema.Int>;
690
+ grouping: Schema.Literal<["ALLGREEN", "HEADGREEN"]>;
691
+ max_build: Schema.refine<number, typeof Schema.Int>;
692
+ max_merge: Schema.refine<number, typeof Schema.Int>;
693
+ merge_method: Schema.Literal<["MERGE", "SQUASH", "REBASE"]>;
694
+ min_merge: Schema.refine<number, typeof Schema.Int>;
695
+ min_wait: Schema.refine<number, typeof Schema.Int>;
696
+ }>>;
697
+ copilot_review: Schema.optional<Schema.Struct<{
698
+ draft_prs: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
699
+ on_push: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
700
+ }>>;
701
+ code_scanning: Schema.optional<Schema.Array$<Schema.Struct<{
702
+ tool: Schema.SchemaClass<string, string, never>;
703
+ alerts: Schema.Literal<["none", "errors", "errors_and_warnings", "all"]>;
704
+ security_alerts: Schema.Literal<["none", "critical", "high_or_higher", "medium_or_higher", "all"]>;
705
+ }>>>;
706
+ workflows: Schema.optional<Schema.Struct<{
707
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
708
+ required: Schema.Array$<Schema.Struct<{
709
+ path: Schema.SchemaClass<string, string, never>;
710
+ ref: Schema.optional<Schema.SchemaClass<string, string, never>>;
711
+ repository_id: Schema.Union<[typeof Schema.Int, Schema.Struct<{
712
+ resolved: Schema.SchemaClass<string, string, never>;
713
+ }>]>;
714
+ sha: Schema.optional<Schema.SchemaClass<string, string, never>>;
715
+ }>>;
716
+ }>>;
717
+ branch_name: Schema.optional<Schema.Array$<Schema.Struct<{
718
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
719
+ pattern: Schema.SchemaClass<string, string, never>;
720
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
721
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
722
+ }>>>;
723
+ name: Schema.SchemaClass<string, string, never>;
724
+ enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
725
+ conditions: Schema.optional<Schema.Struct<{
726
+ ref_name: Schema.optional<Schema.Struct<{
727
+ include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
728
+ default: () => never[];
729
+ }>;
730
+ exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
731
+ default: () => never[];
732
+ }>;
733
+ }>>;
734
+ }>>;
735
+ bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
736
+ actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
737
+ resolved: Schema.SchemaClass<string, string, never>;
738
+ }>]>>;
739
+ actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
740
+ bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
741
+ default: () => "always";
742
+ }>;
743
+ }>>>;
744
+ creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
745
+ update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
746
+ deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
747
+ required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
748
+ required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
749
+ non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
750
+ deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
751
+ targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
752
+ include: Schema.SchemaClass<string, string, never>;
753
+ }>, Schema.Struct<{
754
+ exclude: Schema.SchemaClass<string, string, never>;
755
+ }>]>>]>>;
756
+ status_checks: Schema.optional<Schema.Struct<{
757
+ update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
758
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
759
+ default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
760
+ resolved: Schema.SchemaClass<string, string, never>;
761
+ }>]>>;
762
+ required: Schema.Array$<Schema.Struct<{
763
+ context: Schema.SchemaClass<string, string, never>;
764
+ integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
765
+ resolved: Schema.SchemaClass<string, string, never>;
766
+ }>]>>;
767
+ }>>;
768
+ }>>;
769
+ commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
770
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
771
+ pattern: Schema.SchemaClass<string, string, never>;
772
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
773
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
774
+ }>>>;
775
+ commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
776
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
777
+ pattern: Schema.SchemaClass<string, string, never>;
778
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
779
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
780
+ }>>>;
781
+ committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
782
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
783
+ pattern: Schema.SchemaClass<string, string, never>;
784
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
785
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
786
+ }>>>;
787
+ }>, Schema.Struct<{
788
+ type: Schema.Literal<["tag"]>;
789
+ tag_name: Schema.optional<Schema.Array$<Schema.Struct<{
790
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
791
+ pattern: Schema.SchemaClass<string, string, never>;
792
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
793
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
794
+ }>>>;
795
+ name: Schema.SchemaClass<string, string, never>;
796
+ enforcement: Schema.Literal<["disabled", "active", "evaluate"]>;
797
+ conditions: Schema.optional<Schema.Struct<{
798
+ ref_name: Schema.optional<Schema.Struct<{
799
+ include: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
800
+ default: () => never[];
801
+ }>;
802
+ exclude: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
803
+ default: () => never[];
804
+ }>;
805
+ }>>;
806
+ }>>;
807
+ bypass_actors: Schema.optional<Schema.Array$<Schema.Struct<{
808
+ actor_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
809
+ resolved: Schema.SchemaClass<string, string, never>;
810
+ }>]>>;
811
+ actor_type: Schema.Literal<["Integration", "OrganizationAdmin", "RepositoryRole", "Team", "DeployKey"]>;
812
+ bypass_mode: Schema.optionalWith<Schema.Literal<["always", "pull_request", "exempt"]>, {
813
+ default: () => "always";
814
+ }>;
815
+ }>>>;
816
+ creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
817
+ update: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
818
+ deletion: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
819
+ required_linear_history: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
820
+ required_signatures: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
821
+ non_fast_forward: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
822
+ deployments: Schema.optional<Schema.Array$<typeof Schema.String>>;
823
+ targets: Schema.optional<Schema.Union<[Schema.Literal<["default", "all"]>, Schema.Array$<Schema.Union<[Schema.Struct<{
824
+ include: Schema.SchemaClass<string, string, never>;
825
+ }>, Schema.Struct<{
826
+ exclude: Schema.SchemaClass<string, string, never>;
827
+ }>]>>]>>;
828
+ status_checks: Schema.optional<Schema.Struct<{
829
+ update_branch: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
830
+ on_creation: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
831
+ default_integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
832
+ resolved: Schema.SchemaClass<string, string, never>;
833
+ }>]>>;
834
+ required: Schema.Array$<Schema.Struct<{
835
+ context: Schema.SchemaClass<string, string, never>;
836
+ integration_id: Schema.optional<Schema.Union<[typeof Schema.Int, Schema.Struct<{
837
+ resolved: Schema.SchemaClass<string, string, never>;
838
+ }>]>>;
839
+ }>>;
840
+ }>>;
841
+ commit_message: Schema.optional<Schema.Array$<Schema.Struct<{
842
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
843
+ pattern: Schema.SchemaClass<string, string, never>;
844
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
845
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
846
+ }>>>;
847
+ commit_author_email: Schema.optional<Schema.Array$<Schema.Struct<{
848
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
849
+ pattern: Schema.SchemaClass<string, string, never>;
850
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
851
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
852
+ }>>>;
853
+ committer_email: Schema.optional<Schema.Array$<Schema.Struct<{
854
+ operator: Schema.Literal<["starts_with", "ends_with", "contains", "regex"]>;
855
+ pattern: Schema.SchemaClass<string, string, never>;
856
+ name: Schema.optional<Schema.SchemaClass<string, string, never>>;
857
+ negate: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
858
+ }>>>;
859
+ }>]>;
860
+ type Ruleset = typeof RulesetSchema.Type;
861
+ /** API-compatible payload for creating/updating a ruleset. */
862
+ interface RulesetPayload {
863
+ name: string;
864
+ target: "branch" | "tag";
865
+ enforcement: "disabled" | "active" | "evaluate";
866
+ conditions?: Record<string, unknown>;
867
+ bypass_actors?: ReadonlyArray<Record<string, unknown>>;
868
+ rules?: ReadonlyArray<Record<string, unknown>>;
869
+ }
870
+ /**
871
+ * Builds an API-compatible ruleset payload from the config-level Ruleset.
872
+ * Converts all shorthand fields into the GitHub API rules array format.
873
+ */
874
+ declare function buildRulesetPayload(ruleset: Ruleset): RulesetPayload;
875
+ //#endregion
876
+ //#region src/services/ConfigFiles.d.ts
877
+ declare const CONFIG_FILENAME = "reposets.config.toml";
878
+ declare const CREDENTIALS_FILENAME = "reposets.credentials.toml";
879
+ declare const ReposetsConfigFile: import("effect/Context").Tag<import("xdg-effect").ConfigFileService<{
880
+ readonly environments: {
881
+ readonly [x: string]: {
882
+ readonly reviewers?: readonly {
883
+ readonly type: "Team" | "User";
884
+ readonly id: number;
885
+ }[] | undefined;
886
+ readonly wait_timer?: number | undefined;
887
+ readonly prevent_self_review?: boolean | undefined;
888
+ readonly deployment_branches?: "all" | "protected" | readonly {
889
+ readonly name: string;
890
+ readonly type: "branch" | "tag";
891
+ }[] | undefined;
892
+ };
893
+ };
894
+ readonly secrets: {
895
+ readonly [x: string]: {
896
+ readonly file: {
897
+ readonly [x: string]: string;
898
+ };
899
+ } | {
900
+ readonly value: {
901
+ readonly [x: string]: string | {
902
+ readonly [x: string]: unknown;
903
+ };
904
+ };
905
+ } | {
906
+ readonly resolved: {
907
+ readonly [x: string]: string;
908
+ };
909
+ };
910
+ };
911
+ readonly variables: {
912
+ readonly [x: string]: {
913
+ readonly file: {
914
+ readonly [x: string]: string;
915
+ };
916
+ } | {
917
+ readonly value: {
918
+ readonly [x: string]: string | {
919
+ readonly [x: string]: unknown;
920
+ };
921
+ };
922
+ } | {
923
+ readonly resolved: {
924
+ readonly [x: string]: string;
925
+ };
926
+ };
927
+ };
928
+ readonly rulesets: {
929
+ readonly [x: string]: {
930
+ readonly name: string;
931
+ readonly code_scanning?: readonly {
932
+ readonly tool: string;
933
+ readonly alerts: "all" | "none" | "errors" | "errors_and_warnings";
934
+ readonly security_alerts: "all" | "none" | "critical" | "high_or_higher" | "medium_or_higher";
935
+ }[] | undefined;
936
+ readonly type: "branch";
937
+ readonly pull_requests?: {
938
+ readonly approvals: number;
939
+ readonly dismiss_stale_reviews: boolean;
940
+ readonly code_owner_review: boolean;
941
+ readonly last_push_approval: boolean;
942
+ readonly resolve_threads: boolean;
943
+ readonly merge_methods?: readonly ("merge" | "squash" | "rebase")[] | undefined;
944
+ readonly reviewers?: readonly {
945
+ readonly file_patterns: readonly string[];
946
+ readonly minimum_approvals: number;
947
+ readonly reviewer: {
948
+ readonly type: "Team";
949
+ readonly id: number;
950
+ };
951
+ }[] | undefined;
952
+ } | undefined;
953
+ readonly merge_queue?: {
954
+ readonly check_timeout: number;
955
+ readonly grouping: "ALLGREEN" | "HEADGREEN";
956
+ readonly max_build: number;
957
+ readonly max_merge: number;
958
+ readonly merge_method: "MERGE" | "SQUASH" | "REBASE";
959
+ readonly min_merge: number;
960
+ readonly min_wait: number;
961
+ } | undefined;
962
+ readonly copilot_review?: {
963
+ readonly draft_prs?: boolean | undefined;
964
+ readonly on_push?: boolean | undefined;
965
+ } | undefined;
966
+ readonly workflows?: {
967
+ readonly on_creation?: boolean | undefined;
968
+ readonly required: readonly {
969
+ readonly path: string;
970
+ readonly ref?: string | undefined;
971
+ readonly repository_id: number | {
972
+ readonly resolved: string;
973
+ };
974
+ readonly sha?: string | undefined;
975
+ }[];
976
+ } | undefined;
977
+ readonly branch_name?: readonly {
978
+ readonly name?: string | undefined;
979
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
980
+ readonly pattern: string;
981
+ readonly negate?: boolean | undefined;
982
+ }[] | undefined;
983
+ readonly enforcement: "disabled" | "active" | "evaluate";
984
+ readonly conditions?: {
985
+ readonly ref_name?: {
986
+ readonly include: readonly string[];
987
+ readonly exclude: readonly string[];
988
+ } | undefined;
989
+ } | undefined;
990
+ readonly bypass_actors?: readonly {
991
+ readonly actor_id?: number | {
992
+ readonly resolved: string;
993
+ } | undefined;
994
+ readonly actor_type: "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team" | "DeployKey";
995
+ readonly bypass_mode: "always" | "pull_request" | "exempt";
996
+ }[] | undefined;
997
+ readonly creation?: boolean | undefined;
998
+ readonly update?: boolean | undefined;
999
+ readonly deletion?: boolean | undefined;
1000
+ readonly required_linear_history?: boolean | undefined;
1001
+ readonly required_signatures?: boolean | undefined;
1002
+ readonly non_fast_forward?: boolean | undefined;
1003
+ readonly deployments?: readonly string[] | undefined;
1004
+ readonly targets?: "default" | "all" | readonly ({
1005
+ readonly include: string;
1006
+ } | {
1007
+ readonly exclude: string;
1008
+ })[] | undefined;
1009
+ readonly status_checks?: {
1010
+ readonly update_branch?: boolean | undefined;
1011
+ readonly on_creation?: boolean | undefined;
1012
+ readonly default_integration_id?: number | {
1013
+ readonly resolved: string;
1014
+ } | undefined;
1015
+ readonly required: readonly {
1016
+ readonly context: string;
1017
+ readonly integration_id?: number | {
1018
+ readonly resolved: string;
1019
+ } | undefined;
1020
+ }[];
1021
+ } | undefined;
1022
+ readonly commit_message?: readonly {
1023
+ readonly name?: string | undefined;
1024
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1025
+ readonly pattern: string;
1026
+ readonly negate?: boolean | undefined;
1027
+ }[] | undefined;
1028
+ readonly commit_author_email?: readonly {
1029
+ readonly name?: string | undefined;
1030
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1031
+ readonly pattern: string;
1032
+ readonly negate?: boolean | undefined;
1033
+ }[] | undefined;
1034
+ readonly committer_email?: readonly {
1035
+ readonly name?: string | undefined;
1036
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1037
+ readonly pattern: string;
1038
+ readonly negate?: boolean | undefined;
1039
+ }[] | undefined;
1040
+ } | {
1041
+ readonly name: string;
1042
+ readonly type: "tag";
1043
+ readonly enforcement: "disabled" | "active" | "evaluate";
1044
+ readonly conditions?: {
1045
+ readonly ref_name?: {
1046
+ readonly include: readonly string[];
1047
+ readonly exclude: readonly string[];
1048
+ } | undefined;
1049
+ } | undefined;
1050
+ readonly bypass_actors?: readonly {
1051
+ readonly actor_id?: number | {
1052
+ readonly resolved: string;
1053
+ } | undefined;
1054
+ readonly actor_type: "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team" | "DeployKey";
1055
+ readonly bypass_mode: "always" | "pull_request" | "exempt";
1056
+ }[] | undefined;
1057
+ readonly creation?: boolean | undefined;
1058
+ readonly update?: boolean | undefined;
1059
+ readonly deletion?: boolean | undefined;
1060
+ readonly required_linear_history?: boolean | undefined;
1061
+ readonly required_signatures?: boolean | undefined;
1062
+ readonly non_fast_forward?: boolean | undefined;
1063
+ readonly deployments?: readonly string[] | undefined;
1064
+ readonly targets?: "default" | "all" | readonly ({
1065
+ readonly include: string;
1066
+ } | {
1067
+ readonly exclude: string;
1068
+ })[] | undefined;
1069
+ readonly status_checks?: {
1070
+ readonly update_branch?: boolean | undefined;
1071
+ readonly on_creation?: boolean | undefined;
1072
+ readonly default_integration_id?: number | {
1073
+ readonly resolved: string;
1074
+ } | undefined;
1075
+ readonly required: readonly {
1076
+ readonly context: string;
1077
+ readonly integration_id?: number | {
1078
+ readonly resolved: string;
1079
+ } | undefined;
1080
+ }[];
1081
+ } | undefined;
1082
+ readonly commit_message?: readonly {
1083
+ readonly name?: string | undefined;
1084
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1085
+ readonly pattern: string;
1086
+ readonly negate?: boolean | undefined;
1087
+ }[] | undefined;
1088
+ readonly commit_author_email?: readonly {
1089
+ readonly name?: string | undefined;
1090
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1091
+ readonly pattern: string;
1092
+ readonly negate?: boolean | undefined;
1093
+ }[] | undefined;
1094
+ readonly committer_email?: readonly {
1095
+ readonly name?: string | undefined;
1096
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1097
+ readonly pattern: string;
1098
+ readonly negate?: boolean | undefined;
1099
+ }[] | undefined;
1100
+ readonly tag_name?: readonly {
1101
+ readonly name?: string | undefined;
1102
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1103
+ readonly pattern: string;
1104
+ readonly negate?: boolean | undefined;
1105
+ }[] | undefined;
1106
+ };
1107
+ };
1108
+ readonly owner?: string | undefined;
1109
+ readonly settings: {
1110
+ readonly [x: string]: {
1111
+ readonly [x: string]: unknown;
1112
+ readonly is_template?: boolean | undefined;
1113
+ readonly has_wiki?: boolean | undefined;
1114
+ readonly has_issues?: boolean | undefined;
1115
+ readonly has_projects?: boolean | undefined;
1116
+ readonly has_discussions?: boolean | undefined;
1117
+ readonly has_sponsorships?: boolean | undefined;
1118
+ readonly has_pull_requests?: boolean | undefined;
1119
+ readonly allow_forking?: boolean | undefined;
1120
+ readonly allow_merge_commit?: boolean | undefined;
1121
+ readonly allow_squash_merge?: boolean | undefined;
1122
+ readonly allow_rebase_merge?: boolean | undefined;
1123
+ readonly allow_auto_merge?: boolean | undefined;
1124
+ readonly allow_update_branch?: boolean | undefined;
1125
+ readonly squash_merge_commit_title?: "PR_TITLE" | "COMMIT_OR_PR_TITLE" | undefined;
1126
+ readonly squash_merge_commit_message?: "PR_BODY" | "COMMIT_MESSAGES" | "BLANK" | undefined;
1127
+ readonly merge_commit_title?: "PR_TITLE" | "MERGE_MESSAGE" | undefined;
1128
+ readonly merge_commit_message?: "PR_TITLE" | "PR_BODY" | "BLANK" | undefined;
1129
+ readonly delete_branch_on_merge?: boolean | undefined;
1130
+ readonly web_commit_signoff_required?: boolean | undefined;
1131
+ readonly security_and_analysis?: {
1132
+ readonly advanced_security?: "enabled" | "disabled" | undefined;
1133
+ readonly code_security?: "enabled" | "disabled" | undefined;
1134
+ readonly secret_scanning?: "enabled" | "disabled" | undefined;
1135
+ readonly secret_scanning_push_protection?: "enabled" | "disabled" | undefined;
1136
+ readonly secret_scanning_ai_detection?: "enabled" | "disabled" | undefined;
1137
+ readonly secret_scanning_non_provider_patterns?: "enabled" | "disabled" | undefined;
1138
+ readonly secret_scanning_delegated_alert_dismissal?: "enabled" | "disabled" | undefined;
1139
+ readonly secret_scanning_delegated_bypass?: "enabled" | "disabled" | undefined;
1140
+ readonly delegated_bypass_reviewers?: readonly ({
1141
+ readonly team: string;
1142
+ readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1143
+ } | {
1144
+ readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1145
+ readonly role: string;
1146
+ })[] | undefined;
1147
+ readonly dependabot_security_updates?: "enabled" | "disabled" | undefined;
1148
+ } | undefined;
1149
+ };
1150
+ };
1151
+ readonly security: {
1152
+ readonly [x: string]: {
1153
+ readonly vulnerability_alerts?: boolean | undefined;
1154
+ readonly automated_security_fixes?: boolean | undefined;
1155
+ readonly private_vulnerability_reporting?: boolean | undefined;
1156
+ };
1157
+ };
1158
+ readonly code_scanning: {
1159
+ readonly [x: string]: {
1160
+ readonly state?: "configured" | "not-configured" | undefined;
1161
+ readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
1162
+ readonly query_suite?: "default" | "extended" | undefined;
1163
+ readonly threat_model?: "remote" | "remote_and_local" | undefined;
1164
+ readonly runner_type?: "standard" | "labeled" | undefined;
1165
+ readonly runner_label?: string | undefined;
1166
+ };
1167
+ };
1168
+ readonly log_level: "silent" | "info" | "verbose" | "debug";
1169
+ readonly groups: {
1170
+ readonly [x: string]: {
1171
+ readonly environments?: readonly string[] | undefined;
1172
+ readonly secrets?: {
1173
+ readonly actions?: readonly string[] | undefined;
1174
+ readonly dependabot?: readonly string[] | undefined;
1175
+ readonly codespaces?: readonly string[] | undefined;
1176
+ readonly environments?: {
1177
+ readonly [x: string]: readonly string[];
1178
+ } | undefined;
1179
+ } | undefined;
1180
+ readonly variables?: {
1181
+ readonly actions?: readonly string[] | undefined;
1182
+ readonly environments?: {
1183
+ readonly [x: string]: readonly string[];
1184
+ } | undefined;
1185
+ } | undefined;
1186
+ readonly rulesets?: readonly string[] | undefined;
1187
+ readonly owner?: string | undefined;
1188
+ readonly repos: readonly string[];
1189
+ readonly credentials?: string | undefined;
1190
+ readonly settings?: readonly string[] | undefined;
1191
+ readonly security?: readonly string[] | undefined;
1192
+ readonly code_scanning?: readonly string[] | undefined;
1193
+ readonly cleanup?: {
1194
+ readonly environments: boolean | {
1195
+ readonly preserve: readonly string[];
1196
+ };
1197
+ readonly secrets: {
1198
+ readonly actions: boolean | {
1199
+ readonly preserve: readonly string[];
1200
+ };
1201
+ readonly dependabot: boolean | {
1202
+ readonly preserve: readonly string[];
1203
+ };
1204
+ readonly codespaces: boolean | {
1205
+ readonly preserve: readonly string[];
1206
+ };
1207
+ readonly environments: boolean | {
1208
+ readonly preserve: readonly string[];
1209
+ };
1210
+ };
1211
+ readonly variables: {
1212
+ readonly actions: boolean | {
1213
+ readonly preserve: readonly string[];
1214
+ };
1215
+ readonly environments: boolean | {
1216
+ readonly preserve: readonly string[];
1217
+ };
1218
+ };
1219
+ readonly rulesets: boolean | {
1220
+ readonly preserve: readonly string[];
1221
+ };
1222
+ } | undefined;
1223
+ };
1224
+ };
1225
+ }>, import("xdg-effect").ConfigFileService<{
1226
+ readonly environments: {
1227
+ readonly [x: string]: {
1228
+ readonly reviewers?: readonly {
1229
+ readonly type: "Team" | "User";
1230
+ readonly id: number;
1231
+ }[] | undefined;
1232
+ readonly wait_timer?: number | undefined;
1233
+ readonly prevent_self_review?: boolean | undefined;
1234
+ readonly deployment_branches?: "all" | "protected" | readonly {
1235
+ readonly name: string;
1236
+ readonly type: "branch" | "tag";
1237
+ }[] | undefined;
1238
+ };
1239
+ };
1240
+ readonly secrets: {
1241
+ readonly [x: string]: {
1242
+ readonly file: {
1243
+ readonly [x: string]: string;
1244
+ };
1245
+ } | {
1246
+ readonly value: {
1247
+ readonly [x: string]: string | {
1248
+ readonly [x: string]: unknown;
1249
+ };
1250
+ };
1251
+ } | {
1252
+ readonly resolved: {
1253
+ readonly [x: string]: string;
1254
+ };
1255
+ };
1256
+ };
1257
+ readonly variables: {
1258
+ readonly [x: string]: {
1259
+ readonly file: {
1260
+ readonly [x: string]: string;
1261
+ };
1262
+ } | {
1263
+ readonly value: {
1264
+ readonly [x: string]: string | {
1265
+ readonly [x: string]: unknown;
1266
+ };
1267
+ };
1268
+ } | {
1269
+ readonly resolved: {
1270
+ readonly [x: string]: string;
1271
+ };
1272
+ };
1273
+ };
1274
+ readonly rulesets: {
1275
+ readonly [x: string]: {
1276
+ readonly name: string;
1277
+ readonly code_scanning?: readonly {
1278
+ readonly tool: string;
1279
+ readonly alerts: "all" | "none" | "errors" | "errors_and_warnings";
1280
+ readonly security_alerts: "all" | "none" | "critical" | "high_or_higher" | "medium_or_higher";
1281
+ }[] | undefined;
1282
+ readonly type: "branch";
1283
+ readonly pull_requests?: {
1284
+ readonly approvals: number;
1285
+ readonly dismiss_stale_reviews: boolean;
1286
+ readonly code_owner_review: boolean;
1287
+ readonly last_push_approval: boolean;
1288
+ readonly resolve_threads: boolean;
1289
+ readonly merge_methods?: readonly ("merge" | "squash" | "rebase")[] | undefined;
1290
+ readonly reviewers?: readonly {
1291
+ readonly file_patterns: readonly string[];
1292
+ readonly minimum_approvals: number;
1293
+ readonly reviewer: {
1294
+ readonly type: "Team";
1295
+ readonly id: number;
1296
+ };
1297
+ }[] | undefined;
1298
+ } | undefined;
1299
+ readonly merge_queue?: {
1300
+ readonly check_timeout: number;
1301
+ readonly grouping: "ALLGREEN" | "HEADGREEN";
1302
+ readonly max_build: number;
1303
+ readonly max_merge: number;
1304
+ readonly merge_method: "MERGE" | "SQUASH" | "REBASE";
1305
+ readonly min_merge: number;
1306
+ readonly min_wait: number;
1307
+ } | undefined;
1308
+ readonly copilot_review?: {
1309
+ readonly draft_prs?: boolean | undefined;
1310
+ readonly on_push?: boolean | undefined;
1311
+ } | undefined;
1312
+ readonly workflows?: {
1313
+ readonly on_creation?: boolean | undefined;
1314
+ readonly required: readonly {
1315
+ readonly path: string;
1316
+ readonly ref?: string | undefined;
1317
+ readonly repository_id: number | {
1318
+ readonly resolved: string;
1319
+ };
1320
+ readonly sha?: string | undefined;
1321
+ }[];
1322
+ } | undefined;
1323
+ readonly branch_name?: readonly {
1324
+ readonly name?: string | undefined;
1325
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1326
+ readonly pattern: string;
1327
+ readonly negate?: boolean | undefined;
1328
+ }[] | undefined;
1329
+ readonly enforcement: "disabled" | "active" | "evaluate";
1330
+ readonly conditions?: {
1331
+ readonly ref_name?: {
1332
+ readonly include: readonly string[];
1333
+ readonly exclude: readonly string[];
1334
+ } | undefined;
1335
+ } | undefined;
1336
+ readonly bypass_actors?: readonly {
1337
+ readonly actor_id?: number | {
1338
+ readonly resolved: string;
1339
+ } | undefined;
1340
+ readonly actor_type: "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team" | "DeployKey";
1341
+ readonly bypass_mode: "always" | "pull_request" | "exempt";
1342
+ }[] | undefined;
1343
+ readonly creation?: boolean | undefined;
1344
+ readonly update?: boolean | undefined;
1345
+ readonly deletion?: boolean | undefined;
1346
+ readonly required_linear_history?: boolean | undefined;
1347
+ readonly required_signatures?: boolean | undefined;
1348
+ readonly non_fast_forward?: boolean | undefined;
1349
+ readonly deployments?: readonly string[] | undefined;
1350
+ readonly targets?: "default" | "all" | readonly ({
1351
+ readonly include: string;
1352
+ } | {
1353
+ readonly exclude: string;
1354
+ })[] | undefined;
1355
+ readonly status_checks?: {
1356
+ readonly update_branch?: boolean | undefined;
1357
+ readonly on_creation?: boolean | undefined;
1358
+ readonly default_integration_id?: number | {
1359
+ readonly resolved: string;
1360
+ } | undefined;
1361
+ readonly required: readonly {
1362
+ readonly context: string;
1363
+ readonly integration_id?: number | {
1364
+ readonly resolved: string;
1365
+ } | undefined;
1366
+ }[];
1367
+ } | undefined;
1368
+ readonly commit_message?: readonly {
1369
+ readonly name?: string | undefined;
1370
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1371
+ readonly pattern: string;
1372
+ readonly negate?: boolean | undefined;
1373
+ }[] | undefined;
1374
+ readonly commit_author_email?: readonly {
1375
+ readonly name?: string | undefined;
1376
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1377
+ readonly pattern: string;
1378
+ readonly negate?: boolean | undefined;
1379
+ }[] | undefined;
1380
+ readonly committer_email?: readonly {
1381
+ readonly name?: string | undefined;
1382
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1383
+ readonly pattern: string;
1384
+ readonly negate?: boolean | undefined;
1385
+ }[] | undefined;
1386
+ } | {
1387
+ readonly name: string;
1388
+ readonly type: "tag";
1389
+ readonly enforcement: "disabled" | "active" | "evaluate";
1390
+ readonly conditions?: {
1391
+ readonly ref_name?: {
1392
+ readonly include: readonly string[];
1393
+ readonly exclude: readonly string[];
1394
+ } | undefined;
1395
+ } | undefined;
1396
+ readonly bypass_actors?: readonly {
1397
+ readonly actor_id?: number | {
1398
+ readonly resolved: string;
1399
+ } | undefined;
1400
+ readonly actor_type: "Integration" | "OrganizationAdmin" | "RepositoryRole" | "Team" | "DeployKey";
1401
+ readonly bypass_mode: "always" | "pull_request" | "exempt";
1402
+ }[] | undefined;
1403
+ readonly creation?: boolean | undefined;
1404
+ readonly update?: boolean | undefined;
1405
+ readonly deletion?: boolean | undefined;
1406
+ readonly required_linear_history?: boolean | undefined;
1407
+ readonly required_signatures?: boolean | undefined;
1408
+ readonly non_fast_forward?: boolean | undefined;
1409
+ readonly deployments?: readonly string[] | undefined;
1410
+ readonly targets?: "default" | "all" | readonly ({
1411
+ readonly include: string;
1412
+ } | {
1413
+ readonly exclude: string;
1414
+ })[] | undefined;
1415
+ readonly status_checks?: {
1416
+ readonly update_branch?: boolean | undefined;
1417
+ readonly on_creation?: boolean | undefined;
1418
+ readonly default_integration_id?: number | {
1419
+ readonly resolved: string;
1420
+ } | undefined;
1421
+ readonly required: readonly {
1422
+ readonly context: string;
1423
+ readonly integration_id?: number | {
1424
+ readonly resolved: string;
1425
+ } | undefined;
1426
+ }[];
1427
+ } | undefined;
1428
+ readonly commit_message?: readonly {
1429
+ readonly name?: string | undefined;
1430
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1431
+ readonly pattern: string;
1432
+ readonly negate?: boolean | undefined;
1433
+ }[] | undefined;
1434
+ readonly commit_author_email?: readonly {
1435
+ readonly name?: string | undefined;
1436
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1437
+ readonly pattern: string;
1438
+ readonly negate?: boolean | undefined;
1439
+ }[] | undefined;
1440
+ readonly committer_email?: readonly {
1441
+ readonly name?: string | undefined;
1442
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1443
+ readonly pattern: string;
1444
+ readonly negate?: boolean | undefined;
1445
+ }[] | undefined;
1446
+ readonly tag_name?: readonly {
1447
+ readonly name?: string | undefined;
1448
+ readonly operator: "starts_with" | "ends_with" | "contains" | "regex";
1449
+ readonly pattern: string;
1450
+ readonly negate?: boolean | undefined;
1451
+ }[] | undefined;
1452
+ };
1453
+ };
1454
+ readonly owner?: string | undefined;
1455
+ readonly settings: {
1456
+ readonly [x: string]: {
1457
+ readonly [x: string]: unknown;
1458
+ readonly is_template?: boolean | undefined;
1459
+ readonly has_wiki?: boolean | undefined;
1460
+ readonly has_issues?: boolean | undefined;
1461
+ readonly has_projects?: boolean | undefined;
1462
+ readonly has_discussions?: boolean | undefined;
1463
+ readonly has_sponsorships?: boolean | undefined;
1464
+ readonly has_pull_requests?: boolean | undefined;
1465
+ readonly allow_forking?: boolean | undefined;
1466
+ readonly allow_merge_commit?: boolean | undefined;
1467
+ readonly allow_squash_merge?: boolean | undefined;
1468
+ readonly allow_rebase_merge?: boolean | undefined;
1469
+ readonly allow_auto_merge?: boolean | undefined;
1470
+ readonly allow_update_branch?: boolean | undefined;
1471
+ readonly squash_merge_commit_title?: "PR_TITLE" | "COMMIT_OR_PR_TITLE" | undefined;
1472
+ readonly squash_merge_commit_message?: "PR_BODY" | "COMMIT_MESSAGES" | "BLANK" | undefined;
1473
+ readonly merge_commit_title?: "PR_TITLE" | "MERGE_MESSAGE" | undefined;
1474
+ readonly merge_commit_message?: "PR_TITLE" | "PR_BODY" | "BLANK" | undefined;
1475
+ readonly delete_branch_on_merge?: boolean | undefined;
1476
+ readonly web_commit_signoff_required?: boolean | undefined;
1477
+ readonly security_and_analysis?: {
1478
+ readonly advanced_security?: "enabled" | "disabled" | undefined;
1479
+ readonly code_security?: "enabled" | "disabled" | undefined;
1480
+ readonly secret_scanning?: "enabled" | "disabled" | undefined;
1481
+ readonly secret_scanning_push_protection?: "enabled" | "disabled" | undefined;
1482
+ readonly secret_scanning_ai_detection?: "enabled" | "disabled" | undefined;
1483
+ readonly secret_scanning_non_provider_patterns?: "enabled" | "disabled" | undefined;
1484
+ readonly secret_scanning_delegated_alert_dismissal?: "enabled" | "disabled" | undefined;
1485
+ readonly secret_scanning_delegated_bypass?: "enabled" | "disabled" | undefined;
1486
+ readonly delegated_bypass_reviewers?: readonly ({
1487
+ readonly team: string;
1488
+ readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1489
+ } | {
1490
+ readonly mode?: "ALWAYS" | "EXEMPT" | undefined;
1491
+ readonly role: string;
1492
+ })[] | undefined;
1493
+ readonly dependabot_security_updates?: "enabled" | "disabled" | undefined;
1494
+ } | undefined;
1495
+ };
1496
+ };
1497
+ readonly security: {
1498
+ readonly [x: string]: {
1499
+ readonly vulnerability_alerts?: boolean | undefined;
1500
+ readonly automated_security_fixes?: boolean | undefined;
1501
+ readonly private_vulnerability_reporting?: boolean | undefined;
1502
+ };
1503
+ };
1504
+ readonly code_scanning: {
1505
+ readonly [x: string]: {
1506
+ readonly state?: "configured" | "not-configured" | undefined;
1507
+ readonly languages?: readonly ("actions" | "c-cpp" | "csharp" | "go" | "java-kotlin" | "javascript-typescript" | "python" | "ruby" | "swift")[] | undefined;
1508
+ readonly query_suite?: "default" | "extended" | undefined;
1509
+ readonly threat_model?: "remote" | "remote_and_local" | undefined;
1510
+ readonly runner_type?: "standard" | "labeled" | undefined;
1511
+ readonly runner_label?: string | undefined;
1512
+ };
1513
+ };
1514
+ readonly log_level: "silent" | "info" | "verbose" | "debug";
1515
+ readonly groups: {
1516
+ readonly [x: string]: {
1517
+ readonly environments?: readonly string[] | undefined;
1518
+ readonly secrets?: {
1519
+ readonly actions?: readonly string[] | undefined;
1520
+ readonly dependabot?: readonly string[] | undefined;
1521
+ readonly codespaces?: readonly string[] | undefined;
1522
+ readonly environments?: {
1523
+ readonly [x: string]: readonly string[];
1524
+ } | undefined;
1525
+ } | undefined;
1526
+ readonly variables?: {
1527
+ readonly actions?: readonly string[] | undefined;
1528
+ readonly environments?: {
1529
+ readonly [x: string]: readonly string[];
1530
+ } | undefined;
1531
+ } | undefined;
1532
+ readonly rulesets?: readonly string[] | undefined;
1533
+ readonly owner?: string | undefined;
1534
+ readonly repos: readonly string[];
1535
+ readonly credentials?: string | undefined;
1536
+ readonly settings?: readonly string[] | undefined;
1537
+ readonly security?: readonly string[] | undefined;
1538
+ readonly code_scanning?: readonly string[] | undefined;
1539
+ readonly cleanup?: {
1540
+ readonly environments: boolean | {
1541
+ readonly preserve: readonly string[];
1542
+ };
1543
+ readonly secrets: {
1544
+ readonly actions: boolean | {
1545
+ readonly preserve: readonly string[];
1546
+ };
1547
+ readonly dependabot: boolean | {
1548
+ readonly preserve: readonly string[];
1549
+ };
1550
+ readonly codespaces: boolean | {
1551
+ readonly preserve: readonly string[];
1552
+ };
1553
+ readonly environments: boolean | {
1554
+ readonly preserve: readonly string[];
1555
+ };
1556
+ };
1557
+ readonly variables: {
1558
+ readonly actions: boolean | {
1559
+ readonly preserve: readonly string[];
1560
+ };
1561
+ readonly environments: boolean | {
1562
+ readonly preserve: readonly string[];
1563
+ };
1564
+ };
1565
+ readonly rulesets: boolean | {
1566
+ readonly preserve: readonly string[];
1567
+ };
1568
+ } | undefined;
1569
+ };
1570
+ };
1571
+ }>>;
1572
+ declare const ReposetsCredentialsFile: import("effect/Context").Tag<import("xdg-effect").ConfigFileService<{
1573
+ readonly profiles: {
1574
+ readonly [x: string]: {
1575
+ readonly github_token: string;
1576
+ readonly op_service_account_token?: string | undefined;
1577
+ readonly resolve?: {
1578
+ readonly file?: {
1579
+ readonly [x: string]: string;
1580
+ } | undefined;
1581
+ readonly value?: {
1582
+ readonly [x: string]: string | {
1583
+ readonly [x: string]: unknown;
1584
+ };
1585
+ } | undefined;
1586
+ readonly op?: {
1587
+ readonly [x: string]: string;
1588
+ } | undefined;
1589
+ } | undefined;
1590
+ };
1591
+ };
1592
+ }>, import("xdg-effect").ConfigFileService<{
1593
+ readonly profiles: {
1594
+ readonly [x: string]: {
1595
+ readonly github_token: string;
1596
+ readonly op_service_account_token?: string | undefined;
1597
+ readonly resolve?: {
1598
+ readonly file?: {
1599
+ readonly [x: string]: string;
1600
+ } | undefined;
1601
+ readonly value?: {
1602
+ readonly [x: string]: string | {
1603
+ readonly [x: string]: unknown;
1604
+ };
1605
+ } | undefined;
1606
+ readonly op?: {
1607
+ readonly [x: string]: string;
1608
+ } | undefined;
1609
+ } | undefined;
1610
+ };
1611
+ };
1612
+ }>>;
1613
+ /**
1614
+ * Validates all internal cross-references in a parsed config. Checks that
1615
+ * every group's settings, secrets, variables, rulesets, and environments
1616
+ * references point to defined top-level sections, and that environment-scoped
1617
+ * secret/variable groups reference defined environments. Collects ALL errors
1618
+ * into a single ConfigError.
1619
+ */
1620
+ declare function validateConfigRefs(config: Config): Effect.Effect<Config, ConfigError>;
1621
+ /**
1622
+ * Creates a live Layer providing both config and credentials file services.
1623
+ * When configFlag is Some and points to a directory, prepends StaticDir resolver.
1624
+ * When configFlag is Some and points to a file, prepends ExplicitPath resolver.
1625
+ * Always includes UpwardWalk + XdgConfigResolver as fallback resolvers.
1626
+ * Passes validateConfigRefs as the validate callback on the config spec.
1627
+ */
1628
+ declare function makeConfigFilesLive(configFlag: Option.Option<string>): import("effect/Layer").Layer<import("xdg-effect").ConfigFileService<any> | import("xdg-effect").AppDirs | import("xdg-effect").XdgResolver, never, import("@effect/platform/FileSystem").FileSystem>;
1629
+ /**
1630
+ * Default ConfigFiles layer with no --config flag override.
1631
+ * Used by CLI entrypoint when no flag is provided.
1632
+ */
1633
+ declare const ConfigFilesLive: import("effect/Layer").Layer<import("xdg-effect").ConfigFileService<any> | import("xdg-effect").AppDirs | import("xdg-effect").XdgResolver, never, import("@effect/platform/FileSystem").FileSystem>;
1634
+ //#endregion
1635
+ //#region src/services/OnePasswordClient.d.ts
1636
+ interface OnePasswordClientService {
1637
+ readonly resolve: (reference: string, serviceAccountToken: string) => Effect.Effect<string, OnePasswordError>;
1638
+ }
1639
+ declare const OnePasswordClient_base: Context.TagClass<OnePasswordClient, "OnePasswordClient", OnePasswordClientService>;
1640
+ declare class OnePasswordClient extends OnePasswordClient_base {}
1641
+ declare const OnePasswordClientLive: Layer.Layer<OnePasswordClient, never, never>;
1642
+ declare function OnePasswordClientTest(stubs: Record<string, string>): Layer.Layer<OnePasswordClient>;
1643
+ //#endregion
1644
+ //#region src/services/CredentialResolver.d.ts
1645
+ interface CredentialResolverService {
1646
+ readonly resolveAll: (profile: CredentialProfile, basePath: string) => Effect.Effect<Map<string, string>, ResolveError>;
1647
+ }
1648
+ declare const CredentialResolver_base: Context.TagClass<CredentialResolver, "CredentialResolver", CredentialResolverService>;
1649
+ declare class CredentialResolver extends CredentialResolver_base {}
1650
+ declare const CredentialResolverLive: Layer.Layer<CredentialResolver, never, OnePasswordClient>;
1651
+ //#endregion
1652
+ //#region src/services/GitHubClient.d.ts
1653
+ type SecretScope = "actions" | "dependabot" | "codespaces";
1654
+ interface SecretInfo {
1655
+ name: string;
1656
+ }
1657
+ interface VariableInfo {
1658
+ name: string;
1659
+ }
1660
+ interface RulesetInfo {
1661
+ name: string;
1662
+ id: number;
1663
+ source_type?: string | undefined;
1664
+ }
1665
+ interface EnvironmentInfo {
1666
+ name: string;
1667
+ }
1668
+ type OwnerType = "User" | "Organization";
1669
+ interface GitHubClientService {
1670
+ readonly getOwnerType: (owner: string) => Effect.Effect<OwnerType, GitHubApiError>;
1671
+ readonly syncSecret: (owner: string, repo: string, name: string, value: string, scope: SecretScope) => Effect.Effect<void, GitHubApiError>;
1672
+ readonly syncVariable: (owner: string, repo: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
1673
+ readonly syncSettings: (owner: string, repo: string, settings: Record<string, unknown>) => Effect.Effect<void, GitHubApiError>;
1674
+ readonly syncRuleset: (owner: string, repo: string, name: string, payload: RulesetPayload) => Effect.Effect<void, GitHubApiError>;
1675
+ readonly listSecrets: (owner: string, repo: string, scope: SecretScope) => Effect.Effect<SecretInfo[], GitHubApiError>;
1676
+ readonly listVariables: (owner: string, repo: string) => Effect.Effect<VariableInfo[], GitHubApiError>;
1677
+ readonly listRulesets: (owner: string, repo: string) => Effect.Effect<RulesetInfo[], GitHubApiError>;
1678
+ readonly deleteSecret: (owner: string, repo: string, name: string, scope: SecretScope) => Effect.Effect<void, GitHubApiError>;
1679
+ readonly deleteVariable: (owner: string, repo: string, name: string) => Effect.Effect<void, GitHubApiError>;
1680
+ readonly deleteRuleset: (owner: string, repo: string, rulesetId: number) => Effect.Effect<void, GitHubApiError>;
1681
+ readonly syncEnvironment: (owner: string, repo: string, name: string, config: Record<string, unknown>) => Effect.Effect<void, GitHubApiError>;
1682
+ readonly syncEnvironmentSecret: (owner: string, repo: string, envName: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
1683
+ readonly syncEnvironmentVariable: (owner: string, repo: string, envName: string, name: string, value: string) => Effect.Effect<void, GitHubApiError>;
1684
+ readonly listEnvironments: (owner: string, repo: string) => Effect.Effect<EnvironmentInfo[], GitHubApiError>;
1685
+ readonly listEnvironmentSecrets: (owner: string, repo: string, envName: string) => Effect.Effect<SecretInfo[], GitHubApiError>;
1686
+ readonly listEnvironmentVariables: (owner: string, repo: string, envName: string) => Effect.Effect<VariableInfo[], GitHubApiError>;
1687
+ readonly deleteEnvironment: (owner: string, repo: string, name: string) => Effect.Effect<void, GitHubApiError>;
1688
+ readonly deleteEnvironmentSecret: (owner: string, repo: string, envName: string, name: string) => Effect.Effect<void, GitHubApiError>;
1689
+ readonly deleteEnvironmentVariable: (owner: string, repo: string, envName: string, name: string) => Effect.Effect<void, GitHubApiError>;
1690
+ readonly getVulnerabilityAlerts: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
1691
+ readonly setVulnerabilityAlerts: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
1692
+ readonly getAutomatedSecurityFixes: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
1693
+ readonly setAutomatedSecurityFixes: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
1694
+ readonly getPrivateVulnerabilityReporting: (owner: string, repo: string) => Effect.Effect<boolean, GitHubApiError>;
1695
+ readonly setPrivateVulnerabilityReporting: (owner: string, repo: string, enabled: boolean) => Effect.Effect<void, GitHubApiError>;
1696
+ readonly updateCodeScanningDefaultSetup: (owner: string, repo: string, config: CodeScanningGroup) => Effect.Effect<void, GitHubApiError>;
1697
+ readonly listRepoLanguages: (owner: string, repo: string) => Effect.Effect<ReadonlyArray<string>, GitHubApiError>;
1698
+ readonly resolveTeamId: (org: string, slug: string) => Effect.Effect<number, GitHubApiError>;
1699
+ readonly resolveRoleId: (org: string, name: string) => Effect.Effect<number, GitHubApiError>;
1700
+ }
1701
+ declare const GitHubClient_base: Context.TagClass<GitHubClient, "GitHubClient", GitHubClientService>;
1702
+ declare class GitHubClient extends GitHubClient_base {}
1703
+ declare function GitHubClientLive(token: string): Layer.Layer<GitHubClient>;
1704
+ interface RecordedCall {
1705
+ method: string;
1706
+ args: Record<string, unknown>;
1707
+ }
1708
+ declare function GitHubClientTest(): {
1709
+ layer: Layer.Layer<GitHubClient>;
1710
+ calls: () => RecordedCall[];
1711
+ };
1712
+ //#endregion
1713
+ //#region src/services/SyncLogger.d.ts
1714
+ interface SyncLoggerService {
1715
+ readonly groupStart: (name: string, repoCount: number) => Effect.Effect<void>;
1716
+ readonly repoStart: (owner: string, repo: string) => Effect.Effect<void>;
1717
+ readonly repoSkip: (owner: string, repo: string, reason: string) => Effect.Effect<void>;
1718
+ readonly syncSummary: (resource: "secret" | "variable" | "ruleset" | "environment" | "security feature" | "code scanning", count: number, detail: string) => Effect.Effect<void>;
1719
+ readonly settingsApplied: () => Effect.Effect<void>;
1720
+ readonly cleanupSummary: (resource: string, count: number, names: string[]) => Effect.Effect<void>;
1721
+ readonly syncOperation: (verb: "sync" | "apply" | "delete" | "skip", resource: string, name: string, detail?: string, source?: string) => Effect.Effect<void>;
1722
+ readonly syncError: (context: string, message: string) => Effect.Effect<void>;
1723
+ readonly finish: () => Effect.Effect<void>;
1724
+ }
1725
+ declare const SyncLogger_base: Context.TagClass<SyncLogger, "SyncLogger", SyncLoggerService>;
1726
+ declare class SyncLogger extends SyncLogger_base {}
1727
+ interface SyncLoggerConfig {
1728
+ readonly dryRun: boolean;
1729
+ readonly logLevel: LogLevel;
1730
+ readonly output?: Ref.Ref<string[]>;
1731
+ }
1732
+ declare function SyncLoggerLive(config: SyncLoggerConfig): Layer.Layer<SyncLogger>;
1733
+ //#endregion
1734
+ //#region src/services/SyncEngine.d.ts
1735
+ interface SyncOptions {
1736
+ readonly dryRun: boolean;
1737
+ readonly noCleanup: boolean;
1738
+ readonly groupFilter?: string | undefined;
1739
+ readonly repoFilter?: string | undefined;
1740
+ readonly configDir: string;
1741
+ }
1742
+ interface SyncEngineService {
1743
+ readonly syncAll: (config: Config, credentials: Credentials, options: SyncOptions) => Effect.Effect<void, SyncError>;
1744
+ }
1745
+ declare const SyncEngine_base: Context.TagClass<SyncEngine, "SyncEngine", SyncEngineService>;
1746
+ declare class SyncEngine extends SyncEngine_base {}
1747
+ declare const SyncEngineLive: Layer.Layer<SyncEngine, never, CredentialResolver | GitHubClient | SyncLogger>;
1748
+ //#endregion
1749
+ export { AppDirs, type BypassActor, BypassActorSchema, CONFIG_FILENAME, CREDENTIALS_FILENAME, type Cleanup, CleanupSchema, type CleanupScope, CleanupScopeSchema, type Config, ConfigFile, ConfigFilesLive, ConfigSchema, type CredentialProfile, CredentialProfileSchema, CredentialResolver, CredentialResolverLive, type Credentials, CredentialsSchema, GitHubApiError, GitHubClient, GitHubClientLive, GitHubClientTest, type Group, GroupSchema, type LogLevel, LogLevelSchema, OnePasswordClient, OnePasswordClientLive, OnePasswordClientTest, OnePasswordError, type RecordedCall, ReposetsConfigFile, ReposetsCredentialsFile, ResolveError, type ResolveSection, ResolveSectionSchema, type ResolvedRef, ResolvedRefSchema, type Ruleset, type RulesetPayload, RulesetSchema, type SecretGroup, SecretGroupSchema, SyncEngine, SyncEngineLive, SyncError, SyncLogger, type SyncLoggerConfig, SyncLoggerLive, type VariableGroup, VariableGroupSchema, XdgConfigError, buildRulesetPayload, encryptSecret, makeConfigFilesLive, validateConfigRefs };
1750
+ //# sourceMappingURL=index.d.ts.map