@metabase/client 0.0.0-stage → 0.1.0

package/dist/domain/parameter.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+//#region src/domain/parameter.ts
+const ParameterType = z.enum([
+	"number",
+	"text",
+	"date",
+	"boolean",
+	"date/single",
+	"id",
+	"category",
+	"location/city",
+	"location/state",
+	"location/zip_code",
+	"location/country",
+	"date/range",
+	"date/month-year",
+	"date/quarter-year",
+	"date/relative",
+	"date/all-options",
+	"temporal-unit",
+	"number/!=",
+	"number/<=",
+	"number/=",
+	"number/>=",
+	"number/between",
+	"string/!=",
+	"string/=",
+	"string/contains",
+	"string/does-not-contain",
+	"string/ends-with",
+	"string/starts-with",
+	"boolean/="
+]);
+const TemporalUnit = z.enum([
+	"millisecond",
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year",
+	"second-of-minute",
+	"minute-of-hour",
+	"hour-of-day",
+	"day-of-week",
+	"day-of-month",
+	"day-of-year",
+	"week-of-year",
+	"month-of-year",
+	"quarter-of-year",
+	"year-of-era",
+	"default"
+]);
+const ValuesSourceType = z.enum(["static-list", "card"]);
+const ValuesQueryType = z.enum([
+	"list",
+	"search",
+	"none"
+]);
+const ParameterTemplateTagRef = z.tuple([z.literal("template-tag"), z.union([z.string(), z.object({ id: z.string() }).loose()])]);
+const FieldRefLike = z.tuple([z.string()]).rest(z.unknown());
+const DimensionTarget = z.tuple([z.literal("dimension"), z.union([ParameterTemplateTagRef, FieldRefLike])]).rest(z.unknown());
+const VariableTarget = z.tuple([z.literal("variable"), z.union([ParameterTemplateTagRef, FieldRefLike])]);
+const ParameterTextTagTarget = z.tuple([z.literal("text-tag"), z.string()]);
+const ParameterTarget = z.union([
+	DimensionTarget,
+	VariableTarget,
+	ParameterTextTagTarget,
+	z.number().int(),
+	FieldRefLike
+]);
+const ValuesSourceConfig = z.object({
+	values: z.array(z.unknown()).optional(),
+	card_id: z.number().int().optional(),
+	value_field: FieldRefLike.optional(),
+	label_field: FieldRefLike.optional()
+}).loose();
+const Parameter = z.object({
+	id: z.string(),
+	type: ParameterType,
+	name: z.string().optional(),
+	slug: z.string().optional(),
+	sectionId: z.string().optional(),
+	default: z.unknown().optional(),
+	required: z.boolean().nullable().optional(),
+	filteringParameters: z.array(z.string()).nullable().optional(),
+	target: ParameterTarget.optional(),
+	temporal_units: z.array(TemporalUnit).nullable().optional(),
+	values_query_type: ValuesQueryType.nullable().optional(),
+	values_source_type: ValuesSourceType.nullable().optional(),
+	values_source_config: ValuesSourceConfig.nullable().optional()
+}).loose();
+const ParameterMapping = z.object({
+	parameter_id: z.string(),
+	target: ParameterTarget,
+	card_id: z.number().int().nullable().optional()
+}).loose();
+const ParameterValues = z.object({
+	values: z.array(z.array(z.unknown())),
+	has_more_values: z.boolean()
+}).loose();
+const ParameterValuesCompact = ParameterValues.pick({
+	values: true,
+	has_more_values: true
+}).strip();
+//#endregion
+export { Parameter, ParameterMapping, ParameterTarget, ParameterTemplateTagRef, ParameterTextTagTarget, ParameterType, ParameterValues, ParameterValuesCompact, TemporalUnit, ValuesQueryType, ValuesSourceConfig, ValuesSourceType };

package/dist/domain/permission.d.ts

@@ -0,0 +1,2 @@
+import { a as PermissionsGraph, i as DownloadPermission, n as DataModelPermission, o as ViewDataPermission, r as DatabasePermissions, s as YesNoPermission, t as CreateQueriesPermission } from "../permission-BnCQw5Kp.js";
+export { CreateQueriesPermission, DataModelPermission, DatabasePermissions, DownloadPermission, PermissionsGraph, ViewDataPermission, YesNoPermission };

package/dist/domain/permission.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+//#region src/domain/permission.ts
+const ViewDataPermission = z.enum([
+	"unrestricted",
+	"legacy-no-self-service",
+	"blocked",
+	"sandboxed",
+	"impersonated"
+]);
+const CreateQueriesPermission = z.enum([
+	"query-builder-and-native",
+	"query-builder",
+	"no"
+]);
+const DownloadPermission = z.enum(["full", "limited"]);
+const DataModelPermission = z.literal("all");
+const YesNoPermission = z.enum(["yes", "no"]);
+function granular(value) {
+	const perTable = z.record(z.string(), value);
+	const perSchema = z.record(z.string(), z.union([value, perTable]));
+	return z.union([value, perSchema]);
+}
+const DatabasePermissions = z.object({
+	"view-data": granular(ViewDataPermission).optional(),
+	"create-queries": granular(CreateQueriesPermission).optional(),
+	download: z.object({ schemas: granular(DownloadPermission) }).loose().optional(),
+	"data-model": z.object({ schemas: granular(DataModelPermission) }).loose().optional(),
+	details: YesNoPermission.optional(),
+	transforms: YesNoPermission.optional()
+}).loose();
+const PermissionsGraph = z.object({
+	revision: z.number().int().nonnegative(),
+	groups: z.record(z.string(), z.record(z.string(), DatabasePermissions))
+}).loose();
+//#endregion
+export { CreateQueriesPermission, DataModelPermission, DatabasePermissions, DownloadPermission, PermissionsGraph, ViewDataPermission, YesNoPermission };

package/dist/domain/pulse.d.ts

@@ -0,0 +1,2 @@
+import { a as PulseChannelCompact, c as PulseCompact, d as PulseRecipientCompact, f as PulseScheduleDay, h as PulseUpdateInput, i as PulseChannel, l as PulseCreateInput, m as PulseScheduleType, n as PulseCard, o as PulseChannelDetails, p as PulseScheduleFrame, r as PulseCardCompact, s as PulseChannelType, t as Pulse, u as PulseRecipient } from "../pulse-CMc1Rwdj.js";
+export { Pulse, PulseCard, PulseCardCompact, PulseChannel, PulseChannelCompact, PulseChannelDetails, PulseChannelType, PulseCompact, PulseCreateInput, PulseRecipient, PulseRecipientCompact, PulseScheduleDay, PulseScheduleFrame, PulseScheduleType, PulseUpdateInput };

package/dist/domain/pulse.js

@@ -0,0 +1,133 @@
+import { Parameter } from "./parameter.js";
+import { z } from "zod";
+//#region src/domain/pulse.ts
+const PulseChannelType = z.enum([
+	"email",
+	"slack",
+	"http"
+]);
+const PulseScheduleType = z.enum([
+	"hourly",
+	"daily",
+	"weekly",
+	"monthly"
+]);
+const PulseScheduleDay = z.enum([
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat",
+	"sun"
+]);
+const PulseScheduleFrame = z.enum([
+	"first",
+	"mid",
+	"last"
+]);
+const PulseChannelDetails = z.object({ channel: z.string().optional() }).loose();
+const PulseRecipient = z.object({
+	id: z.number().int().nullable().optional(),
+	email: z.string()
+}).loose();
+const PulseRecipientCompact = PulseRecipient.pick({
+	id: true,
+	email: true
+}).strip();
+const PulseChannel = z.object({
+	id: z.number().int().optional(),
+	channel_type: PulseChannelType,
+	channel_id: z.number().int().nullable().optional(),
+	enabled: z.boolean(),
+	schedule_type: PulseScheduleType,
+	schedule_hour: z.number().int().nullable(),
+	schedule_day: PulseScheduleDay.nullable(),
+	schedule_frame: PulseScheduleFrame.nullable(),
+	details: PulseChannelDetails.optional(),
+	recipients: z.array(PulseRecipient)
+}).loose();
+const PulseChannelCompact = PulseChannel.pick({
+	channel_type: true,
+	enabled: true,
+	schedule_type: true,
+	schedule_hour: true,
+	schedule_day: true,
+	schedule_frame: true,
+	details: true
+}).strip().extend({ recipients: z.array(PulseRecipientCompact) });
+const PulseCard = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	dashboard_card_id: z.number().int().nullable(),
+	include_csv: z.boolean(),
+	include_xls: z.boolean()
+}).loose();
+const PulseCardCompact = PulseCard.pick({
+	id: true,
+	name: true,
+	dashboard_card_id: true,
+	include_csv: true,
+	include_xls: true
+}).strip();
+const Pulse = z.object({
+	id: z.number().int(),
+	name: z.string().nullable(),
+	creator_id: z.number().int(),
+	dashboard_id: z.number().int().nullable(),
+	collection_id: z.number().int().nullable(),
+	archived: z.boolean(),
+	skip_if_empty: z.boolean(),
+	parameters: z.array(Parameter),
+	cards: z.array(PulseCard),
+	channels: z.array(PulseChannel)
+}).loose();
+const PulseCompact = Pulse.pick({
+	id: true,
+	name: true,
+	dashboard_id: true,
+	collection_id: true,
+	archived: true,
+	skip_if_empty: true
+}).strip().extend({
+	cards: z.array(PulseCardCompact),
+	channels: z.array(PulseChannelCompact)
+});
+const PulseRecipientInput = z.union([z.object({ id: z.number().int().positive() }).loose(), z.object({ email: z.string().min(1) }).loose()]);
+const PulseCardInput = z.object({
+	id: z.number().int().positive(),
+	include_csv: z.boolean(),
+	include_xls: z.boolean(),
+	dashboard_card_id: z.number().int().positive().nullable().optional(),
+	format_rows: z.boolean().optional(),
+	pivot_results: z.boolean().optional()
+}).loose();
+const PulseChannelInput = z.object({
+	channel_type: PulseChannelType,
+	enabled: z.boolean().default(true),
+	schedule_type: PulseScheduleType,
+	schedule_hour: z.number().int().min(0).max(23).nullable().optional(),
+	schedule_day: PulseScheduleDay.nullable().optional(),
+	schedule_frame: PulseScheduleFrame.nullable().optional(),
+	channel_id: z.number().int().positive().nullable().optional(),
+	details: PulseChannelDetails.optional(),
+	recipients: z.array(PulseRecipientInput).optional()
+}).loose();
+const PulseCreateInput = z.object({
+	name: z.string().min(1),
+	dashboard_id: z.number().int().positive(),
+	cards: z.array(PulseCardInput).min(1),
+	channels: z.array(PulseChannelInput).min(1),
+	skip_if_empty: z.boolean().optional(),
+	parameters: z.array(Parameter).optional()
+}).loose();
+const PulseUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	cards: z.array(PulseCardInput).min(1).optional(),
+	channels: z.array(PulseChannelInput).min(1).optional(),
+	skip_if_empty: z.boolean().optional(),
+	archived: z.boolean().optional(),
+	parameters: z.array(Parameter).optional()
+}).loose();
+//#endregion
+export { Pulse, PulseCard, PulseCardCompact, PulseChannel, PulseChannelCompact, PulseChannelDetails, PulseChannelType, PulseCompact, PulseCreateInput, PulseRecipient, PulseRecipientCompact, PulseScheduleDay, PulseScheduleFrame, PulseScheduleType, PulseUpdateInput };

package/dist/domain/query.d.ts

@@ -0,0 +1,2 @@
+import { a as VisualizationSettings, i as SortDirection, n as ExportFormat, r as PivotExportFormat, t as DatasetQuery } from "../query-Xsin530u.js";
+export { DatasetQuery, ExportFormat, PivotExportFormat, SortDirection, VisualizationSettings };

package/dist/domain/query.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/domain/query.ts
+const DatasetQuery = z.object({}).loose().refine((value) => "lib/type" in value || "type" in value, { message: "dataset_query must include \"lib/type\" (MBQL 5) or \"type\" (legacy MBQL/native); empty `{}` is rejected" }).describe("MBQL 5, legacy MBQL, or native query");
+const ExportFormat = z.enum([
+	"csv",
+	"json",
+	"xlsx"
+]);
+const PivotExportFormat = ExportFormat.exclude(["json"]);
+const VisualizationSettings = z.record(z.string(), z.unknown());
+const SortDirection = z.enum(["asc", "desc"]);
+//#endregion
+export { DatasetQuery, ExportFormat, PivotExportFormat, SortDirection, VisualizationSettings };

package/dist/domain/replacement.d.ts

@@ -0,0 +1,2 @@
+import { a as ReplacementEntityType, c as ReplacementRun, d as ReplacementRunStatus, f as ReplacementSourceInput, i as ReplacementColumnMapping, l as ReplacementRunCompact, n as ReplacementColumn, o as ReplacementError, p as ReplacementSourceType, r as ReplacementColumnError, s as ReplacementModelWithTransformInput, t as ReplacementCheck, u as ReplacementRunStarted } from "../replacement-CyvtbxGg.js";
+export { ReplacementCheck, ReplacementColumn, ReplacementColumnError, ReplacementColumnMapping, ReplacementEntityType, ReplacementError, ReplacementModelWithTransformInput, ReplacementRun, ReplacementRunCompact, ReplacementRunStarted, ReplacementRunStatus, ReplacementSourceInput, ReplacementSourceType };

package/dist/domain/replacement.js

@@ -0,0 +1,93 @@
+import { FieldBaseType, FieldSemanticType } from "./field.js";
+import { TransformTarget } from "./transform.js";
+import { z } from "zod";
+//#region src/domain/replacement.ts
+const ReplacementSourceType = z.enum(["card", "table"]);
+const ReplacementEntityType = z.enum([...ReplacementSourceType.options, "transform"]);
+const ReplacementRunStatus = z.enum([
+	"pending",
+	"started",
+	"succeeded",
+	"failed",
+	"canceled",
+	"timeout"
+]);
+const ReplacementRun = z.object({
+	id: z.number().int(),
+	status: ReplacementRunStatus,
+	is_active: z.literal(true).nullable(),
+	source_entity_type: ReplacementEntityType,
+	source_entity_id: z.number().int(),
+	target_entity_type: ReplacementEntityType,
+	target_entity_id: z.number().int(),
+	progress: z.number().min(0).max(1).nullable(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable()
+}).loose();
+const ReplacementRunCompact = ReplacementRun.pick({
+	id: true,
+	status: true,
+	source_entity_type: true,
+	source_entity_id: true,
+	target_entity_type: true,
+	target_entity_id: true,
+	progress: true,
+	message: true,
+	start_time: true,
+	end_time: true
+}).strip();
+const ReplacementColumn = z.object({
+	id: z.number().int().nullable(),
+	name: z.string(),
+	display_name: z.string(),
+	base_type: FieldBaseType.nullable(),
+	effective_type: FieldBaseType.nullable(),
+	semantic_type: FieldSemanticType.nullable()
+});
+const ReplacementColumnError = z.enum([
+	"column-type-mismatch",
+	"missing-primary-key",
+	"missing-foreign-key",
+	"foreign-key-mismatch"
+]);
+const ReplacementColumnMatched = z.object({
+	source: ReplacementColumn,
+	target: ReplacementColumn,
+	errors: z.array(ReplacementColumnError).optional()
+}).strict();
+const ReplacementColumnMissingOnTarget = z.object({ source: ReplacementColumn }).strict();
+const ReplacementColumnMissingOnSource = z.object({ target: ReplacementColumn }).strict();
+const ReplacementColumnMapping = z.union([
+	ReplacementColumnMatched,
+	ReplacementColumnMissingOnTarget,
+	ReplacementColumnMissingOnSource
+]);
+const ReplacementError = z.enum([
+	"cycle-detected",
+	"database-mismatch",
+	"incompatible-implicit-joins",
+	"affects-gtap-policies"
+]);
+const ReplacementCheck = z.object({
+	success: z.boolean(),
+	errors: z.array(ReplacementError).optional(),
+	column_mappings: z.array(ReplacementColumnMapping).optional()
+});
+const ReplacementSourceInput = z.object({
+	source_entity_id: z.number().int().positive(),
+	source_entity_type: ReplacementSourceType,
+	target_entity_id: z.number().int().positive(),
+	target_entity_type: ReplacementSourceType
+}).strict();
+const ReplacementModelWithTransformInput = z.object({
+	card_id: z.number().int().positive(),
+	transform_name: z.string(),
+	transform_target: TransformTarget,
+	target_collection_id: z.number().int().positive().nullable().optional(),
+	transform_tag_ids: z.array(z.number().int().positive()).nullable().optional()
+}).strict();
+const ReplacementRunStarted = z.object({ run_id: z.number().int().positive() });
+//#endregion
+export { ReplacementCheck, ReplacementColumn, ReplacementColumnError, ReplacementColumnMapping, ReplacementEntityType, ReplacementError, ReplacementModelWithTransformInput, ReplacementRun, ReplacementRunCompact, ReplacementRunStarted, ReplacementRunStatus, ReplacementSourceInput, ReplacementSourceType };

package/dist/domain/revision.d.ts

@@ -0,0 +1,2 @@
+import { a as RevisionRevertInput, i as RevisionRevert, n as RevisionCompact, o as RevisionRow, r as RevisionEntity, t as Revision } from "../revision-CQBPhohA.js";
+export { Revision, RevisionCompact, RevisionEntity, RevisionRevert, RevisionRevertInput, RevisionRow };

package/dist/domain/revision.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+//#region src/domain/revision.ts
+const RevisionEntity = z.enum([
+	"card",
+	"dashboard",
+	"document",
+	"measure",
+	"segment",
+	"transform",
+	"transform-test"
+]);
+const RevisionUser = z.object({
+	id: z.number().int(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable(),
+	common_name: z.string()
+}).loose();
+const Revision = z.object({
+	id: z.number().int(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean(),
+	diff: z.object({}).loose().nullable(),
+	description: z.string(),
+	has_multiple_changes: z.boolean(),
+	user: RevisionUser
+}).loose();
+const RevisionCompact = Revision.pick({
+	id: true,
+	timestamp: true,
+	is_creation: true,
+	is_reversion: true,
+	description: true,
+	user: true
+}).strip();
+const RevisionRow = z.object({
+	id: z.number().int(),
+	model: z.string(),
+	model_id: z.number().int(),
+	user_id: z.number().int(),
+	object: z.object({}).loose(),
+	timestamp: z.string(),
+	is_creation: z.boolean(),
+	is_reversion: z.boolean(),
+	most_recent: z.boolean()
+}).loose();
+const RevisionRevertInput = z.object({
+	entity: RevisionEntity,
+	id: z.number().int().positive(),
+	revision_id: z.number().int().positive()
+}).strict();
+const RevisionReverted = z.object({
+	outcome: z.literal("reverted"),
+	revision: Revision
+});
+const RevisionUnchanged = z.object({
+	outcome: z.literal("unchanged"),
+	revision: RevisionRow
+});
+const RevisionRevert = z.discriminatedUnion("outcome", [RevisionReverted, RevisionUnchanged]);
+//#endregion
+export { Revision, RevisionCompact, RevisionEntity, RevisionRevert, RevisionRevertInput, RevisionRow };

package/dist/domain/search.d.ts

@@ -0,0 +1,2 @@
+import { i as SearchResultCompact, n as SearchModel, r as SearchResult, t as SEARCH_MODELS } from "../search-NZR6iRBs.js";
+export { SEARCH_MODELS, SearchModel, SearchResult, SearchResultCompact };

package/dist/domain/search.js

@@ -0,0 +1,63 @@
+import { ModerationStatus } from "./moderation-review.js";
+import { z } from "zod";
+//#region src/domain/search.ts
+const SEARCH_MODELS = [
+	"card",
+	"dataset",
+	"metric",
+	"dashboard",
+	"collection",
+	"database",
+	"table",
+	"segment",
+	"measure",
+	"document",
+	"exploration",
+	"action",
+	"transform",
+	"indexed-entity"
+];
+const SearchModel = z.enum(SEARCH_MODELS);
+const SearchResultCollection = z.object({
+	id: z.union([
+		z.number().int(),
+		z.string(),
+		z.null()
+	]),
+	name: z.string().nullable(),
+	authority_level: z.string().nullable(),
+	type: z.string().nullable()
+}).loose();
+const SearchResultDashboard = z.object({
+	id: z.number().int(),
+	name: z.string()
+}).loose();
+const SearchResult = z.object({
+	id: z.union([z.number().int(), z.string()]),
+	name: z.string(),
+	model: SearchModel,
+	description: z.string().nullable().optional(),
+	archived: z.boolean().nullable(),
+	collection: SearchResultCollection.nullable(),
+	result_metadata: z.array(z.unknown()).nullable().optional(),
+	database_id: z.number().int().nullable().optional(),
+	database_name: z.string().nullable().optional(),
+	table_schema: z.string().nullable().optional(),
+	table_name: z.string().nullable().optional(),
+	moderated_status: ModerationStatus.nullable().optional(),
+	dashboard: SearchResultDashboard.nullable().optional()
+}).loose();
+const SearchResultCompact = SearchResult.pick({
+	id: true,
+	name: true,
+	model: true,
+	description: true,
+	database_name: true,
+	table_schema: true,
+	table_name: true
+}).strip().extend({ dashboard: SearchResultDashboard.pick({
+	id: true,
+	name: true
+}).strip().nullable().optional() });
+//#endregion
+export { SEARCH_MODELS, SearchModel, SearchResult, SearchResultCompact };

package/dist/domain/segment.d.ts

@@ -0,0 +1,2 @@
+import { i as SegmentUpdateInput, n as SegmentCompact, r as SegmentCreateInput, t as Segment } from "../segment-pj3wklGe.js";
+export { Segment, SegmentCompact, SegmentCreateInput, SegmentUpdateInput };

package/dist/domain/segment.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+//#region src/domain/segment.ts
+const Segment = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	archived: z.boolean(),
+	table_id: z.number().int(),
+	definition: z.unknown(),
+	creator_id: z.number().int(),
+	entity_id: z.string().nullable(),
+	show_in_getting_started: z.boolean().nullable(),
+	caveats: z.string().nullable(),
+	points_of_interest: z.string().nullable(),
+	definition_description: z.string().nullable().optional(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const SegmentCompact = Segment.pick({
+	id: true,
+	name: true,
+	description: true,
+	archived: true,
+	table_id: true
+}).strip();
+const SegmentDefinition = z.record(z.string(), z.unknown()).describe("MBQL query holding the filter");
+const SegmentCreateInput = z.object({
+	name: z.string().min(1),
+	table_id: z.number().int().positive(),
+	definition: SegmentDefinition,
+	description: z.string().nullable().optional()
+}).loose();
+const SegmentUpdateInput = z.object({
+	name: z.string().min(1).nullable().optional(),
+	definition: SegmentDefinition.nullable().optional(),
+	revision_message: z.string().min(1),
+	archived: z.boolean().nullable().optional(),
+	description: z.string().nullable().optional(),
+	caveats: z.string().nullable().optional(),
+	points_of_interest: z.string().nullable().optional(),
+	show_in_getting_started: z.boolean().nullable().optional()
+}).loose();
+//#endregion
+export { Segment, SegmentCompact, SegmentCreateInput, SegmentUpdateInput };

package/dist/domain/session-properties.d.ts

@@ -0,0 +1,2 @@
+import { n as TokenFeatures, t as SessionProperties } from "../session-properties-COtlxAcK.js";
+export { SessionProperties, TokenFeatures };

package/dist/domain/session-properties.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+//#region src/domain/session-properties.ts
+const ServerVersion = z.object({
+	tag: z.string(),
+	date: z.string().optional(),
+	hash: z.string().optional()
+}).loose();
+const TokenFeatures = z.record(z.string(), z.boolean());
+const SessionProperties = z.object({
+	version: ServerVersion,
+	"token-features": TokenFeatures.optional()
+}).loose();
+//#endregion
+export { SessionProperties, TokenFeatures };

package/dist/domain/setting.d.ts

@@ -0,0 +1,2 @@
+import { n as SettingCompact, r as SettingValue, t as Setting } from "../setting-DXuQGXGF.js";
+export { Setting, SettingCompact, SettingValue };

package/dist/domain/setting.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/domain/setting.ts
+const Setting = z.object({
+	key: z.string(),
+	value: z.unknown(),
+	is_env_setting: z.boolean(),
+	env_name: z.string(),
+	description: z.string(),
+	default: z.unknown()
+}).loose();
+const SettingCompact = Setting.pick({
+	key: true,
+	value: true,
+	is_env_setting: true,
+	env_name: true
+}).strip();
+const SettingValue = z.object({
+	key: z.string(),
+	value: z.unknown()
+});
+//#endregion
+export { Setting, SettingCompact, SettingValue };

package/dist/domain/setup.d.ts

@@ -0,0 +1,2 @@
+import { n as SetupResult, r as SetupResultCompact, t as SetupInput } from "../setup-Ez_U7GmM.js";
+export { SetupInput, SetupResult, SetupResultCompact };

package/dist/domain/setup.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+//#region src/domain/setup.ts
+const SetupUserInput = z.object({
+	first_name: z.string().min(1).nullable().optional(),
+	last_name: z.string().min(1).nullable().optional(),
+	email: z.email(),
+	password: z.string().min(1).describe("must satisfy the server's password complexity requirements")
+}).loose();
+const SetupPrefsInput = z.object({
+	site_name: z.string().min(1),
+	site_locale: z.string().min(1).nullable().optional()
+}).loose();
+const SetupInput = z.object({
+	token: z.string().min(1),
+	user: SetupUserInput,
+	prefs: SetupPrefsInput
+}).loose();
+const SetupResult = z.object({ id: z.string() }).loose();
+const SetupResultCompact = SetupResult.pick({ id: true }).strip();
+//#endregion
+export { SetupInput, SetupResult, SetupResultCompact };

package/dist/domain/snippet.d.ts

@@ -0,0 +1,2 @@
+import { i as SnippetUpdateInput, n as SnippetCompact, r as SnippetCreateInput, t as Snippet } from "../snippet-hEV429Pv.js";
+export { Snippet, SnippetCompact, SnippetCreateInput, SnippetUpdateInput };