@herd-labs/sdk 0.4.0 → 0.5.0

package/dist/src/live/CodeBlocksServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient8 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient2 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CodeBlocksServiceLive.d.ts
-declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfig | effect_unstable_http_HttpClient8.HttpClient>;
+declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfigService | effect_unstable_http_HttpClient2.HttpClient>;
 //#endregion
 export { CodeBlocksServiceLive };

package/dist/src/live/CodeBlocksServiceLive.js

@@ -1,5 +1,5 @@
 import { CodeBlockNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { CodeBlockExecuteResponse, CodeBlocksSearchResponse, CreateCodeBlockResponse, CreateCodeVersionResponse, PublishCodeBlockResponse } from "../schemas/codeblocks.js";
+import { CodeBlockExecuteResponseSchema, CodeBlocksSearchResponseSchema, CreateCodeBlockResponseSchema, CreateCodeVersionResponseSchema, PublishCodeBlockResponseSchema } from "../schemas/codeblocks.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Array, Effect, Layer, Option, pipe } from "effect";
@@ -13,20 +13,20 @@ const mapNotFound = (id) => Effect.catch((error) => {
 const CodeBlocksServiceLive = Layer.effect(CodeBlocksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to create code block"))),
-		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponse)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code block"))),
+		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
 		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId)),
-		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponse)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
+		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponseSchema)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
 		get: (id) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody({
 			scope: "user",
 			limit: 1,
 			filters: { id }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
 			onNone: () => Effect.fail(new CodeBlockNotFoundError({ id })),
 			onSome: Effect.succeed
 		})))),
-		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
+		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
 		updateCode: (definitionId, codeId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code")), mapNotFound(definitionId)),
 		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId))
 	};

package/dist/src/live/CollectionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient9 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CollectionsServiceLive.d.ts
-declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfig | effect_unstable_http_HttpClient9.HttpClient>;
+declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfigService | effect_unstable_http_HttpClient0.HttpClient>;
 //#endregion
 export { CollectionsServiceLive };

package/dist/src/live/CollectionsServiceLive.js

@@ -1,5 +1,5 @@
 import { CollectionNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { Collection, CollectionsSearchResponse, CreateCollectionResponse } from "../schemas/collections.js";
+import { CollectionSchema, CollectionsSearchResponseSchema, CreateCollectionResponseSchema } from "../schemas/collections.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -13,9 +13,9 @@ const mapNotFound = (id) => Effect.catch((error) => {
 const CollectionsServiceLive = Layer.effect(CollectionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponse)), Effect.mapError(ensureServiceError("Failed to create collection"))),
-		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Collection)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponse)), Effect.mapError(ensureServiceError("Failed to search collections"))),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create collection"))),
+		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionSchema)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search collections"))),
 		update: (collectionId, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/collections/${collectionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update collection")), mapNotFound(collectionId))
 	};
 }));

package/dist/src/live/ContractsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient7 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
 
 //#region src/live/ContractsServiceLive.d.ts
-declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfig | effect_unstable_http_HttpClient7.HttpClient>;
+declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfigService | effect_unstable_http_HttpClient13.HttpClient>;
 //#endregion
 export { ContractsServiceLive };

package/dist/src/live/ContractsServiceLive.js

@@ -1,6 +1,6 @@
 import { ensureServiceError } from "../errors.js";
-import { ContractDiff, ContractMetadata, GetContractCodeResponse } from "../schemas/contracts.js";
-import { DeployedContracts } from "../schemas/wallets.js";
+import { ContractDiffSchema, ContractMetadataSchema, GetContractCodeResponseSchema } from "../schemas/contracts.js";
+import { DeployedContractsSchema } from "../schemas/wallets.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -14,16 +14,16 @@ const ContractsServiceLive = Layer.effect(ContractsService, Effect.gen(function*
 			contractAddress: address,
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiff)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiffSchema)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
 		getContractCode: (blockchain, params) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/code/query"), { body: jsonBody({
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponse)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
-		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponseSchema)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
+		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContractsSchema)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
 		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
 			contractAddress: address,
 			blockchain
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadata)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadataSchema)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
 	};
 }));
 

package/dist/src/live/DocsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { DocsService } from "../services/DocsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient10 from "effect/unstable/http/HttpClient";
 
 //#region src/live/DocsServiceLive.d.ts
-declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfig | effect_unstable_http_HttpClient11.HttpClient>;
+declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfigService | effect_unstable_http_HttpClient10.HttpClient>;
 //#endregion
 export { DocsServiceLive };

package/dist/src/live/DocsServiceLive.js

@@ -1,5 +1,5 @@
 import { DocNotFoundError, ensureServiceError } from "../errors.js";
-import { DocContent, DocEntry } from "../schemas/docs.js";
+import { DocContentSchema, DocEntrySchema } from "../schemas/docs.js";
 import { DocsService } from "../services/DocsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Schema, pipe } from "effect";
@@ -9,13 +9,13 @@ import { HttpClientResponse } from "effect/unstable/http";
 const DocsServiceLive = Layer.effect(DocsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntry))), Effect.mapError(ensureServiceError("Failed to list docs"))),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntrySchema))), Effect.mapError(ensureServiceError("Failed to list docs"))),
 		read: (docId) => Effect.gen(function* () {
 			const response = yield* pipe(client.get(makeUrl(baseUrl, `/v1/docs/${encodeURIComponent(docId)}`)), Effect.flatMap(checkStatus), Effect.mapError((error) => {
 				const wrapped = ensureServiceError("Failed to read doc")(error);
 				return wrapped.metadata["status"] === 404 ? new DocNotFoundError({ docId }) : wrapped;
 			}));
-			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContent)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
+			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContentSchema)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
 		})
 	};
 }));

package/dist/src/live/GroupsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { GroupsService } from "../services/GroupsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient5 from "effect/unstable/http/HttpClient";
 
 //#region src/live/GroupsServiceLive.d.ts
-declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfig | effect_unstable_http_HttpClient12.HttpClient>;
+declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfigService | effect_unstable_http_HttpClient5.HttpClient>;
 //#endregion
 export { GroupsServiceLive };

package/dist/src/live/GroupsServiceLive.js

@@ -1,5 +1,5 @@
 import { ServiceError, ensureServiceError } from "../errors.js";
-import { CreateGroupResponse, EditGroupMetadataResponse, GroupDetails, ListGroupsResponse, ProposalResponse } from "../schemas/groups.js";
+import { CreateGroupResponseSchema, EditGroupMetadataResponseSchema, GroupDetailsSchema, ListGroupsResponseSchema, ProposalResponseSchema } from "../schemas/groups.js";
 import { GroupNotFoundError, GroupsService } from "../services/GroupsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -13,12 +13,12 @@ const mapNotFound = (groupId) => Effect.catch((error) => {
 const GroupsServiceLive = Layer.effect(GroupsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponse)), Effect.mapError(ensureServiceError("Failed to create group"))),
-		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponse)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
-		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetails)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
-		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
-		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
-		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
+		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponseSchema)), Effect.mapError(ensureServiceError("Failed to create group"))),
+		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponseSchema)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
+		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetailsSchema)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponseSchema)), Effect.mapError(ensureServiceError("Failed to list groups"))),
+		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
+		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
 	};
 }));
 

package/dist/src/live/HalServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { HalService } from "../services/HalService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
 
 //#region src/live/HalServiceLive.d.ts
-declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | effect_unstable_http_HttpClient13.HttpClient>;
+declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfigService | effect_unstable_http_HttpClient11.HttpClient>;
 //#endregion
 export { HalServiceLive };

package/dist/src/live/HalServiceLive.js

@@ -1,5 +1,5 @@
 import { ServiceError, SimulationError, ensureServiceError } from "../errors.js";
-import { EvaluateExistingResponse, EvaluateResponse } from "../schemas/hal.js";
+import { EvaluateExistingResponseSchema, EvaluateResponseSchema } from "../schemas/hal.js";
 import { HalService } from "../services/HalService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -15,8 +15,8 @@ const mapSimulationError = Effect.catch((error) => {
 });
 const HalServiceLive = Layer.effect(HalService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
-	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponse)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
-	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponse)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
+	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
+	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
 	return {
 		evaluate: (params) => callEvaluate({
 			expression: params.expression,

package/dist/src/live/TransactionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient4 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
 
 //#region src/live/TransactionsServiceLive.d.ts
-declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfig | effect_unstable_http_HttpClient4.HttpClient>;
+declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfigService | effect_unstable_http_HttpClient12.HttpClient>;
 //#endregion
 export { TransactionsServiceLive };

package/dist/src/live/TransactionsServiceLive.js

@@ -1,5 +1,5 @@
 import { ensureServiceError } from "../errors.js";
-import { LatestEventTransactions, LatestFunctionTransactions, TransactionQueryResponse } from "../schemas/transactions.js";
+import { LatestEventTransactionsSchema, LatestFunctionTransactionsSchema, TransactionQueryResponseSchema } from "../schemas/transactions.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Option, Record, pipe } from "effect";
@@ -31,15 +31,15 @@ const TransactionsServiceLive = Layer.effect(TransactionsService, Effect.gen(fun
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactions)), Effect.mapError(ensureServiceError("Failed to get latest event transactions"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactionsSchema)), Effect.mapError(ensureServiceError("Failed to get latest event transactions"))),
 		getLatestFunctionTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_function_transactions`, {
 			...latestTxParamsToSnakeCaseQuery(params),
 			...toOptionalQuery({
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactions)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
-		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponse)), Effect.mapError(ensureServiceError("Failed to get transaction")))
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactionsSchema)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
+		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponseSchema)), Effect.mapError(ensureServiceError("Failed to get transaction")))
 	};
 }));
 

package/dist/src/live/WalletsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient5 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient9 from "effect/unstable/http/HttpClient";
 
 //#region src/live/WalletsServiceLive.d.ts
-declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | effect_unstable_http_HttpClient5.HttpClient>;
+declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfigService | effect_unstable_http_HttpClient9.HttpClient>;
 //#endregion
 export { WalletsServiceLive };

package/dist/src/live/WalletsServiceLive.js

@@ -1,5 +1,5 @@
 import { ensureServiceError } from "../errors.js";
-import { DeployedContracts, TokenActivity, TransactionActivity, WalletOverview } from "../schemas/wallets.js";
+import { DeployedContractsSchema, TokenActivitySchema, TransactionActivitySchema, WalletOverviewSchema } from "../schemas/wallets.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, Option, Record, pipe } from "effect";
@@ -15,13 +15,13 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 			after_timestamp: params?.afterTimestamp,
 			before_blocknumber: params?.beforeBlocknumber,
 			after_blocknumber: params?.afterBlocknumber
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContractsSchema)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
 		getOverview: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/overview`, {
 			before_timestamp: params?.beforeTimestamp,
 			after_timestamp: params?.afterTimestamp,
 			before_blocknumber: params?.beforeBlocknumber,
 			after_blocknumber: params?.afterBlocknumber
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WalletOverview)), Effect.mapError(ensureServiceError("Failed to get wallet overview"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WalletOverviewSchema)), Effect.mapError(ensureServiceError("Failed to get wallet overview"))),
 		getTokenActivity: (blockchain, address, tokenAddress, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/tokens/${tokenAddress}`, {
 			page: params?.page,
 			before_timestamp: params?.beforeTimestamp,
@@ -30,7 +30,7 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 			after_blocknumber: params?.afterBlocknumber,
 			from_address: params?.fromAddress,
 			to_address: params?.toAddress
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenActivity)), Effect.mapError(ensureServiceError("Failed to get token activity"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenActivitySchema)), Effect.mapError(ensureServiceError("Failed to get token activity"))),
 		getTransactions: (query) => {
 			const optionalFields = Record.getSomes(Record.map({
 				from_address: query.fromAddress,
@@ -45,7 +45,7 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 				blockchain: query.blockchain,
 				page: query.page ?? 1,
 				...optionalFields
-			}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionActivity)), Effect.mapError(ensureServiceError("Failed to get wallet transactions")));
+			}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionActivitySchema)), Effect.mapError(ensureServiceError("Failed to get wallet transactions")));
 		}
 	};
 }));

package/dist/src/live/http.d.ts

@@ -1,4 +1,4 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ServiceError } from "../errors.js";
 import { Effect, Schema } from "effect";
 import { HttpBody, HttpClient, HttpClientResponse, UrlParams } from "effect/unstable/http";
@@ -9,7 +9,7 @@ declare const makeUrl: (baseUrl: string, path: string, queryParams?: object) =>
 declare const authorizedClient: Effect.Effect<{
   baseUrl: string;
   client: HttpClient.HttpClient.With<effect_unstable_http_HttpClientError0.HttpClientError, never>;
-}, never, HerdConfig | HttpClient.HttpClient>;
+}, never, HerdConfigService | HttpClient.HttpClient>;
 declare const handleJsonResponse: <S extends Schema.Top>(schema: S) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<S["Type"], ServiceError, S["DecodingServices"]>;
 declare const checkStatus: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<HttpClientResponse.HttpClientResponse, ServiceError>;
 declare const jsonBody: (body: unknown) => HttpBody.HttpBody;

package/dist/src/live/http.js

@@ -1,4 +1,4 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ServiceError } from "../errors.js";
 import { Effect, Function, Result, pipe } from "effect";
 import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse, UrlParams } from "effect/unstable/http";
@@ -13,7 +13,7 @@ const makeUrl = (baseUrl, path, queryParams) => {
 	return url.toString();
 };
 const authorizedClient = Effect.gen(function* () {
-	const config = yield* HerdConfig;
+	const config = yield* HerdConfigService;
 	const client = yield* HttpClient.HttpClient;
 	const { baseUrl, authHeaders } = Result.match(config, {
 		onFailure: ({ baseUrl: innerBaseUrl, oauthAccessToken }) => ({