@jsm-mit/sultana-core-motoko-package 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# Sultana Core Motoko Package
+
+A TypeScript library for interacting with the Sultana Core Motoko actor on the Internet Computer (IC) platform. 

package/declarations/sultana-core-motoko/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@icp-sdk/core/agent";
+import type { Principal } from "@icp-sdk/core/principal";
+import type { IDL } from "@icp-sdk/core/candid";
+
+import { _SERVICE } from './sultana-core-motoko.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const sultana_core_motoko: ActorSubclass<_SERVICE>;

package/declarations/sultana-core-motoko/index.js

@@ -0,0 +1,42 @@
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./sultana-core-motoko.did.js";
+export { idlFactory } from "./sultana-core-motoko.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_SULTANA_CORE_MOTOKO;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};
+
+export const sultana_core_motoko = canisterId ? createActor(canisterId) : undefined;

package/declarations/sultana-core-motoko/sultana-core-motoko.did

@@ -0,0 +1,246 @@
+type UserProfile = 
+ record {
+   avatarUrl: opt text;
+   id: principal;
+   name: text;
+ };
+type UpdateSalonServiceArgs = 
+ record {
+   active: bool;
+   duration: nat;
+   name: text;
+   price: nat;
+   serviceId: SalonServiceId;
+   serviceTypeIds: vec ServiceTypeId;
+   workerIds: vec principal;
+ };
+type UpdateProfileArgs = 
+ record {
+   avatarUrl: opt text;
+   name: text;
+ };
+type ToggleWorkerCapabilityArgs = 
+ record {
+   canPerform: bool;
+   salonId: SalonId;
+   salonServiceId: SalonServiceId;
+   workerId: principal;
+ };
+type TimeMask = vec nat64;
+type SetWeeklyTemplateArgs = 
+ record {
+   day: nat;
+   mask: TimeMask;
+   salonId: SalonId;
+   workerId: principal;
+ };
+type SetDailyScheduleArgs = 
+ record {
+   date: nat64;
+   mask: TimeMask;
+   workerId: principal;
+ };
+type ServiceTypeId = text;
+type SalonServiceId = text;
+type SalonService = 
+ record {
+   active: bool;
+   address: text;
+   duration: nat;
+   geohash6: Geohash;
+   id: SalonServiceId;
+   location: Coordinate;
+   name: text;
+   price: nat;
+   salonId: SalonId;
+   serviceTypeIds: vec ServiceTypeId;
+   workerIds: vec principal;
+ };
+type SalonId = text;
+type Salon = 
+ record {
+   active: bool;
+   address: text;
+   geohash6: Geohash;
+   id: SalonId;
+   location: Coordinate;
+   name: text;
+   ownerId: principal;
+ };
+type Result_9 = 
+ variant {
+   err: Error;
+   ok: SalonId;
+ };
+type Result_8 = 
+ variant {
+   err: Error;
+   ok: TimeMask;
+ };
+type Result_7 = 
+ variant {
+   err: Error;
+   ok: vec nat64;
+ };
+type Result_6 = 
+ variant {
+   err: Error;
+   ok: vec Salon;
+ };
+type Result_5 = 
+ variant {
+   err: Error;
+   ok: vec SalonService;
+ };
+type Result_4 = 
+ variant {
+   err: Error;
+   ok: vec UserProfile;
+ };
+type Result_3 = 
+ variant {
+   err: Error;
+   ok: vec ServiceTypeId;
+ };
+type Result_2 = 
+ variant {
+   err: Error;
+   ok: principal;
+ };
+type Result_11 = 
+ variant {
+   err: Error;
+   ok: SalonServiceId;
+ };
+type Result_10 = 
+ variant {
+   err: Error;
+   ok: AppointmentId;
+ };
+type Result_1 = 
+ variant {
+   err: Error;
+   ok: UserProfile;
+ };
+type Result = 
+ variant {
+   err: Error;
+   ok;
+ };
+type RequestToJoinArgs = record {salonId: SalonId;};
+type RemoveDailyScheduleArgs = 
+ record {
+   date: nat64;
+   workerId: principal;
+ };
+type RejectCandidateArgs = 
+ record {
+   salonId: SalonId;
+   workerId: principal;
+ };
+type GetDayFromWeeklyTemplateArgs = 
+ record {
+   day: DayOfWeek;
+   salonId: SalonId;
+   workerId: principal;
+ };
+type GetDailyScheduleArgs = 
+ record {
+   date: nat64;
+   workerId: principal;
+ };
+type Geohash = text;
+type Error = 
+ variant {
+   AlreadyExists;
+   InvalidData: text;
+   NotAuthorized: text;
+   NotFound;
+   ReturnsNull;
+ };
+type DayOfWeek = nat;
+type CreateSalonArgs = 
+ record {
+   address: text;
+   geohash6: Geohash;
+   location: Coordinate;
+   name: text;
+ };
+type Coordinate = 
+ record {
+   lat: float64;
+   lng: float64;
+ };
+type BookAppointmentArgs = 
+ record {
+   dateMidnight: nat64;
+   dayOfWeek: DayOfWeek;
+   notes: opt text;
+   salonId: SalonId;
+   salonServiceId: SalonServiceId;
+   startTime: nat64;
+   workerId: principal;
+ };
+type AppointmentId = text;
+type AddSalonServiceArgs = 
+ record {
+   active: bool;
+   duration: nat;
+   name: text;
+   price: nat;
+   salonId: SalonId;
+   serviceTypeIds: vec ServiceTypeId;
+   workerIds: vec principal;
+ };
+type AcceptWorkerArgs = 
+ record {
+   salonId: SalonId;
+   workerId: principal;
+ };
+service : {
+  /// Owner accepts a candidate into the team
+  acceptWorker: (args: AcceptWorkerArgs) -> (Result);
+  /// Adds a new service to a specific salon
+  addSalonService: (args: AddSalonServiceArgs) -> (Result_11);
+  addServiceType: (id: ServiceTypeId) -> (Result);
+  bookAppointment: (args: BookAppointmentArgs) -> (Result_10);
+  /// Creates a new salon and links it to the caller
+  createSalon: (args: CreateSalonArgs) -> (Result_9);
+  getAllProfiles: () -> (Result_4) query;
+  /// Returns a specific daily override if it exists
+  getDailySchedule: (args: GetDailyScheduleArgs) -> (Result_8) query;
+  getDayFromWeeklyTemplate: (args: GetDayFromWeeklyTemplateArgs) ->
+   (Result_7) query;
+  getMyProfile: () -> (Result_1) query;
+  /// Pobiera listę salonów aktualnie zalogowanego właściciela (używa indeksu)
+  getMySalons: () -> (Result_6) query;
+  /// Returns the list of profiles waiting for approval (Owner only)
+  getSalonCandidates: (salonId: SalonId) -> (Result_4) query;
+  /// Pobiera listę usług salonu na podstawie jego ID (widok dla właściciela)
+  getSalonServicesBySalonId: (salonId: SalonId) -> (Result_5) query;
+  /// Pobiera listę profili wszystkich pracowników zatrudnionych w danym salonie
+  getSalonWorkers: (salonId: SalonId) -> (Result_4) query;
+  getServiceTypes: () -> (Result_3) query;
+  getSystemAdmin: () -> (Result_2) query;
+  /// Właściciel odrzuca prośbę kandydata o dołączenie do zespołu
+  rejectCandidate: (args: RejectCandidateArgs) -> (Result);
+  removeDailySchedule: (args: RemoveDailyScheduleArgs) -> (Result);
+  /// Permanently removes a salon service and cleans up search indexes
+  removeSalonService: (serviceId: SalonServiceId) -> (Result);
+  removeServiceType: (id: ServiceTypeId) -> (Result);
+  /// Owner removes a worker from the salon team
+  removeWorkerFromSalon: (salonId: SalonId, workerId: principal) -> (Result);
+  /// Worker sends a request to join a specific salon
+  requestToJoinSalon: (args: RequestToJoinArgs) -> (Result);
+  setDailySchedule: (args: SetDailyScheduleArgs) -> (Result);
+  /// Ustawia lub zmienia administratora systemu.
+  /// Jeśli admin nie jest ustawiony, pierwszy wywołujący staje się adminem.
+  /// Jeśli jest ustawiony, tylko obecny admin może przekazać uprawnienia komuś innemu.
+  setSystemAdmin: (newAdmin: opt principal) -> (Result_2);
+  setWeeklyTemplate: (args: SetWeeklyTemplateArgs) -> (Result);
+  /// Umożliwia właścicielowi salonu przypisanie lub odebranie uprawnień pracownikowi do wykonywania konkretnej usługi.
+  toggleWorkerCapability: (args: ToggleWorkerCapabilityArgs) -> (Result);
+  updateMyProfile: (args: UpdateProfileArgs) -> (Result_1);
+  /// Updates an existing service with new details and synchronizes the index
+  updateSalonService: (args: UpdateSalonServiceArgs) -> (Result);
+}

package/declarations/sultana-core-motoko/sultana-core-motoko.did.d.ts

@@ -0,0 +1,225 @@
+import type { Principal } from '@icp-sdk/core/principal';
+import type { ActorMethod } from '@icp-sdk/core/agent';
+import type { IDL } from '@icp-sdk/core/candid';
+
+export interface AcceptWorkerArgs {
+  'workerId' : Principal,
+  'salonId' : SalonId,
+}
+export interface AddSalonServiceArgs {
+  'duration' : bigint,
+  'active' : boolean,
+  'name' : string,
+  'serviceTypeIds' : Array<ServiceTypeId>,
+  'workerIds' : Array<Principal>,
+  'price' : bigint,
+  'salonId' : SalonId,
+}
+export type AppointmentId = string;
+export interface BookAppointmentArgs {
+  'startTime' : bigint,
+  'workerId' : Principal,
+  'dayOfWeek' : DayOfWeek,
+  'salonServiceId' : SalonServiceId,
+  'notes' : [] | [string],
+  'dateMidnight' : bigint,
+  'salonId' : SalonId,
+}
+export interface Coordinate { 'lat' : number, 'lng' : number }
+export interface CreateSalonArgs {
+  'name' : string,
+  'address' : string,
+  'location' : Coordinate,
+  'geohash6' : Geohash,
+}
+export type DayOfWeek = bigint;
+export type Error = { 'NotFound' : null } |
+  { 'NotAuthorized' : string } |
+  { 'InvalidData' : string } |
+  { 'AlreadyExists' : null } |
+  { 'ReturnsNull' : null };
+export type Geohash = string;
+export interface GetDailyScheduleArgs {
+  'workerId' : Principal,
+  'date' : bigint,
+}
+export interface GetDayFromWeeklyTemplateArgs {
+  'day' : DayOfWeek,
+  'workerId' : Principal,
+  'salonId' : SalonId,
+}
+export interface RejectCandidateArgs {
+  'workerId' : Principal,
+  'salonId' : SalonId,
+}
+export interface RemoveDailyScheduleArgs {
+  'workerId' : Principal,
+  'date' : bigint,
+}
+export interface RequestToJoinArgs { 'salonId' : SalonId }
+export type Result = { 'ok' : null } |
+  { 'err' : Error };
+export type Result_1 = { 'ok' : UserProfile } |
+  { 'err' : Error };
+export type Result_10 = { 'ok' : AppointmentId } |
+  { 'err' : Error };
+export type Result_11 = { 'ok' : SalonServiceId } |
+  { 'err' : Error };
+export type Result_2 = { 'ok' : Principal } |
+  { 'err' : Error };
+export type Result_3 = { 'ok' : Array<ServiceTypeId> } |
+  { 'err' : Error };
+export type Result_4 = { 'ok' : Array<UserProfile> } |
+  { 'err' : Error };
+export type Result_5 = { 'ok' : Array<SalonService> } |
+  { 'err' : Error };
+export type Result_6 = { 'ok' : Array<Salon> } |
+  { 'err' : Error };
+export type Result_7 = { 'ok' : BigUint64Array | bigint[] } |
+  { 'err' : Error };
+export type Result_8 = { 'ok' : TimeMask } |
+  { 'err' : Error };
+export type Result_9 = { 'ok' : SalonId } |
+  { 'err' : Error };
+export interface Salon {
+  'id' : SalonId,
+  'active' : boolean,
+  'ownerId' : Principal,
+  'name' : string,
+  'address' : string,
+  'location' : Coordinate,
+  'geohash6' : Geohash,
+}
+export type SalonId = string;
+export interface SalonService {
+  'id' : SalonServiceId,
+  'duration' : bigint,
+  'active' : boolean,
+  'name' : string,
+  'serviceTypeIds' : Array<ServiceTypeId>,
+  'workerIds' : Array<Principal>,
+  'address' : string,
+  'price' : bigint,
+  'location' : Coordinate,
+  'geohash6' : Geohash,
+  'salonId' : SalonId,
+}
+export type SalonServiceId = string;
+export type ServiceTypeId = string;
+export interface SetDailyScheduleArgs {
+  'workerId' : Principal,
+  'date' : bigint,
+  'mask' : TimeMask,
+}
+export interface SetWeeklyTemplateArgs {
+  'day' : bigint,
+  'workerId' : Principal,
+  'mask' : TimeMask,
+  'salonId' : SalonId,
+}
+export type TimeMask = BigUint64Array | bigint[];
+export interface ToggleWorkerCapabilityArgs {
+  'workerId' : Principal,
+  'canPerform' : boolean,
+  'salonServiceId' : SalonServiceId,
+  'salonId' : SalonId,
+}
+export interface UpdateProfileArgs {
+  'name' : string,
+  'avatarUrl' : [] | [string],
+}
+export interface UpdateSalonServiceArgs {
+  'duration' : bigint,
+  'active' : boolean,
+  'name' : string,
+  'serviceTypeIds' : Array<ServiceTypeId>,
+  'workerIds' : Array<Principal>,
+  'serviceId' : SalonServiceId,
+  'price' : bigint,
+}
+export interface UserProfile {
+  'id' : Principal,
+  'name' : string,
+  'avatarUrl' : [] | [string],
+}
+export interface _SERVICE {
+  /**
+   * / Owner accepts a candidate into the team
+   */
+  'acceptWorker' : ActorMethod<[AcceptWorkerArgs], Result>,
+  /**
+   * / Adds a new service to a specific salon
+   */
+  'addSalonService' : ActorMethod<[AddSalonServiceArgs], Result_11>,
+  'addServiceType' : ActorMethod<[ServiceTypeId], Result>,
+  'bookAppointment' : ActorMethod<[BookAppointmentArgs], Result_10>,
+  /**
+   * / Creates a new salon and links it to the caller
+   */
+  'createSalon' : ActorMethod<[CreateSalonArgs], Result_9>,
+  'getAllProfiles' : ActorMethod<[], Result_4>,
+  /**
+   * / Returns a specific daily override if it exists
+   */
+  'getDailySchedule' : ActorMethod<[GetDailyScheduleArgs], Result_8>,
+  'getDayFromWeeklyTemplate' : ActorMethod<
+    [GetDayFromWeeklyTemplateArgs],
+    Result_7
+  >,
+  'getMyProfile' : ActorMethod<[], Result_1>,
+  /**
+   * / Pobiera listę salonów aktualnie zalogowanego właściciela (używa indeksu)
+   */
+  'getMySalons' : ActorMethod<[], Result_6>,
+  /**
+   * / Returns the list of profiles waiting for approval (Owner only)
+   */
+  'getSalonCandidates' : ActorMethod<[SalonId], Result_4>,
+  /**
+   * / Pobiera listę usług salonu na podstawie jego ID (widok dla właściciela)
+   */
+  'getSalonServicesBySalonId' : ActorMethod<[SalonId], Result_5>,
+  /**
+   * / Pobiera listę profili wszystkich pracowników zatrudnionych w danym salonie
+   */
+  'getSalonWorkers' : ActorMethod<[SalonId], Result_4>,
+  'getServiceTypes' : ActorMethod<[], Result_3>,
+  'getSystemAdmin' : ActorMethod<[], Result_2>,
+  /**
+   * / Właściciel odrzuca prośbę kandydata o dołączenie do zespołu
+   */
+  'rejectCandidate' : ActorMethod<[RejectCandidateArgs], Result>,
+  'removeDailySchedule' : ActorMethod<[RemoveDailyScheduleArgs], Result>,
+  /**
+   * / Permanently removes a salon service and cleans up search indexes
+   */
+  'removeSalonService' : ActorMethod<[SalonServiceId], Result>,
+  'removeServiceType' : ActorMethod<[ServiceTypeId], Result>,
+  /**
+   * / Owner removes a worker from the salon team
+   */
+  'removeWorkerFromSalon' : ActorMethod<[SalonId, Principal], Result>,
+  /**
+   * / Worker sends a request to join a specific salon
+   */
+  'requestToJoinSalon' : ActorMethod<[RequestToJoinArgs], Result>,
+  'setDailySchedule' : ActorMethod<[SetDailyScheduleArgs], Result>,
+  /**
+   * / Ustawia lub zmienia administratora systemu.
+   * / Jeśli admin nie jest ustawiony, pierwszy wywołujący staje się adminem.
+   * / Jeśli jest ustawiony, tylko obecny admin może przekazać uprawnienia komuś innemu.
+   */
+  'setSystemAdmin' : ActorMethod<[[] | [Principal]], Result_2>,
+  'setWeeklyTemplate' : ActorMethod<[SetWeeklyTemplateArgs], Result>,
+  /**
+   * / Umożliwia właścicielowi salonu przypisanie lub odebranie uprawnień pracownikowi do wykonywania konkretnej usługi.
+   */
+  'toggleWorkerCapability' : ActorMethod<[ToggleWorkerCapabilityArgs], Result>,
+  'updateMyProfile' : ActorMethod<[UpdateProfileArgs], Result_1>,
+  /**
+   * / Updates an existing service with new details and synchronizes the index
+   */
+  'updateSalonService' : ActorMethod<[UpdateSalonServiceArgs], Result>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/declarations/sultana-core-motoko/sultana-core-motoko.did.js

@@ -0,0 +1,177 @@
+export const idlFactory = ({ IDL }) => {
+  const SalonId = IDL.Text;
+  const AcceptWorkerArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'salonId' : SalonId,
+  });
+  const Error = IDL.Variant({
+    'NotFound' : IDL.Null,
+    'NotAuthorized' : IDL.Text,
+    'InvalidData' : IDL.Text,
+    'AlreadyExists' : IDL.Null,
+    'ReturnsNull' : IDL.Null,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Error });
+  const ServiceTypeId = IDL.Text;
+  const AddSalonServiceArgs = IDL.Record({
+    'duration' : IDL.Nat,
+    'active' : IDL.Bool,
+    'name' : IDL.Text,
+    'serviceTypeIds' : IDL.Vec(ServiceTypeId),
+    'workerIds' : IDL.Vec(IDL.Principal),
+    'price' : IDL.Nat,
+    'salonId' : SalonId,
+  });
+  const SalonServiceId = IDL.Text;
+  const Result_11 = IDL.Variant({ 'ok' : SalonServiceId, 'err' : Error });
+  const DayOfWeek = IDL.Nat;
+  const BookAppointmentArgs = IDL.Record({
+    'startTime' : IDL.Nat64,
+    'workerId' : IDL.Principal,
+    'dayOfWeek' : DayOfWeek,
+    'salonServiceId' : SalonServiceId,
+    'notes' : IDL.Opt(IDL.Text),
+    'dateMidnight' : IDL.Nat64,
+    'salonId' : SalonId,
+  });
+  const AppointmentId = IDL.Text;
+  const Result_10 = IDL.Variant({ 'ok' : AppointmentId, 'err' : Error });
+  const Coordinate = IDL.Record({ 'lat' : IDL.Float64, 'lng' : IDL.Float64 });
+  const Geohash = IDL.Text;
+  const CreateSalonArgs = IDL.Record({
+    'name' : IDL.Text,
+    'address' : IDL.Text,
+    'location' : Coordinate,
+    'geohash6' : Geohash,
+  });
+  const Result_9 = IDL.Variant({ 'ok' : SalonId, 'err' : Error });
+  const UserProfile = IDL.Record({
+    'id' : IDL.Principal,
+    'name' : IDL.Text,
+    'avatarUrl' : IDL.Opt(IDL.Text),
+  });
+  const Result_4 = IDL.Variant({ 'ok' : IDL.Vec(UserProfile), 'err' : Error });
+  const GetDailyScheduleArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'date' : IDL.Nat64,
+  });
+  const TimeMask = IDL.Vec(IDL.Nat64);
+  const Result_8 = IDL.Variant({ 'ok' : TimeMask, 'err' : Error });
+  const GetDayFromWeeklyTemplateArgs = IDL.Record({
+    'day' : DayOfWeek,
+    'workerId' : IDL.Principal,
+    'salonId' : SalonId,
+  });
+  const Result_7 = IDL.Variant({ 'ok' : IDL.Vec(IDL.Nat64), 'err' : Error });
+  const Result_1 = IDL.Variant({ 'ok' : UserProfile, 'err' : Error });
+  const Salon = IDL.Record({
+    'id' : SalonId,
+    'active' : IDL.Bool,
+    'ownerId' : IDL.Principal,
+    'name' : IDL.Text,
+    'address' : IDL.Text,
+    'location' : Coordinate,
+    'geohash6' : Geohash,
+  });
+  const Result_6 = IDL.Variant({ 'ok' : IDL.Vec(Salon), 'err' : Error });
+  const SalonService = IDL.Record({
+    'id' : SalonServiceId,
+    'duration' : IDL.Nat,
+    'active' : IDL.Bool,
+    'name' : IDL.Text,
+    'serviceTypeIds' : IDL.Vec(ServiceTypeId),
+    'workerIds' : IDL.Vec(IDL.Principal),
+    'address' : IDL.Text,
+    'price' : IDL.Nat,
+    'location' : Coordinate,
+    'geohash6' : Geohash,
+    'salonId' : SalonId,
+  });
+  const Result_5 = IDL.Variant({ 'ok' : IDL.Vec(SalonService), 'err' : Error });
+  const Result_3 = IDL.Variant({
+    'ok' : IDL.Vec(ServiceTypeId),
+    'err' : Error,
+  });
+  const Result_2 = IDL.Variant({ 'ok' : IDL.Principal, 'err' : Error });
+  const RejectCandidateArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'salonId' : SalonId,
+  });
+  const RemoveDailyScheduleArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'date' : IDL.Nat64,
+  });
+  const RequestToJoinArgs = IDL.Record({ 'salonId' : SalonId });
+  const SetDailyScheduleArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'date' : IDL.Nat64,
+    'mask' : TimeMask,
+  });
+  const SetWeeklyTemplateArgs = IDL.Record({
+    'day' : IDL.Nat,
+    'workerId' : IDL.Principal,
+    'mask' : TimeMask,
+    'salonId' : SalonId,
+  });
+  const ToggleWorkerCapabilityArgs = IDL.Record({
+    'workerId' : IDL.Principal,
+    'canPerform' : IDL.Bool,
+    'salonServiceId' : SalonServiceId,
+    'salonId' : SalonId,
+  });
+  const UpdateProfileArgs = IDL.Record({
+    'name' : IDL.Text,
+    'avatarUrl' : IDL.Opt(IDL.Text),
+  });
+  const UpdateSalonServiceArgs = IDL.Record({
+    'duration' : IDL.Nat,
+    'active' : IDL.Bool,
+    'name' : IDL.Text,
+    'serviceTypeIds' : IDL.Vec(ServiceTypeId),
+    'workerIds' : IDL.Vec(IDL.Principal),
+    'serviceId' : SalonServiceId,
+    'price' : IDL.Nat,
+  });
+  return IDL.Service({
+    'acceptWorker' : IDL.Func([AcceptWorkerArgs], [Result], []),
+    'addSalonService' : IDL.Func([AddSalonServiceArgs], [Result_11], []),
+    'addServiceType' : IDL.Func([ServiceTypeId], [Result], []),
+    'bookAppointment' : IDL.Func([BookAppointmentArgs], [Result_10], []),
+    'createSalon' : IDL.Func([CreateSalonArgs], [Result_9], []),
+    'getAllProfiles' : IDL.Func([], [Result_4], ['query']),
+    'getDailySchedule' : IDL.Func(
+        [GetDailyScheduleArgs],
+        [Result_8],
+        ['query'],
+      ),
+    'getDayFromWeeklyTemplate' : IDL.Func(
+        [GetDayFromWeeklyTemplateArgs],
+        [Result_7],
+        ['query'],
+      ),
+    'getMyProfile' : IDL.Func([], [Result_1], ['query']),
+    'getMySalons' : IDL.Func([], [Result_6], ['query']),
+    'getSalonCandidates' : IDL.Func([SalonId], [Result_4], ['query']),
+    'getSalonServicesBySalonId' : IDL.Func([SalonId], [Result_5], ['query']),
+    'getSalonWorkers' : IDL.Func([SalonId], [Result_4], ['query']),
+    'getServiceTypes' : IDL.Func([], [Result_3], ['query']),
+    'getSystemAdmin' : IDL.Func([], [Result_2], ['query']),
+    'rejectCandidate' : IDL.Func([RejectCandidateArgs], [Result], []),
+    'removeDailySchedule' : IDL.Func([RemoveDailyScheduleArgs], [Result], []),
+    'removeSalonService' : IDL.Func([SalonServiceId], [Result], []),
+    'removeServiceType' : IDL.Func([ServiceTypeId], [Result], []),
+    'removeWorkerFromSalon' : IDL.Func([SalonId, IDL.Principal], [Result], []),
+    'requestToJoinSalon' : IDL.Func([RequestToJoinArgs], [Result], []),
+    'setDailySchedule' : IDL.Func([SetDailyScheduleArgs], [Result], []),
+    'setSystemAdmin' : IDL.Func([IDL.Opt(IDL.Principal)], [Result_2], []),
+    'setWeeklyTemplate' : IDL.Func([SetWeeklyTemplateArgs], [Result], []),
+    'toggleWorkerCapability' : IDL.Func(
+        [ToggleWorkerCapabilityArgs],
+        [Result],
+        [],
+      ),
+    'updateMyProfile' : IDL.Func([UpdateProfileArgs], [Result_1], []),
+    'updateSalonService' : IDL.Func([UpdateSalonServiceArgs], [Result], []),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SultanaCoreMotokoActor } from "./sultana-core-motoko-actor.js";
+export type { AcceptWorkerArgs, AddSalonServiceArgs, BookAppointmentArgs, GetDailyScheduleArgs, CreateSalonArgs, GetDayFromWeeklyTemplateArgs, RejectCandidateArgs, RemoveDailyScheduleArgs, RequestToJoinArgs, SetDailyScheduleArgs, SetWeeklyTemplateArgs, ToggleWorkerCapabilityArgs, UpdateProfileArgs, UpdateSalonServiceArgs } from '../declarations/sultana-core-motoko/sultana-core-motoko.did.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,YAAY,EACR,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EACf,4BAA4B,EAC5B,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,EAC1B,iBAAiB,EACjB,sBAAsB,EACzB,MAAM,gEAAgE,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { SultanaCoreMotokoActor } from "./sultana-core-motoko-actor.js";

package/dist/sultana-core-motoko-actor.d.ts

@@ -0,0 +1,21 @@
+import { type Identity } from "@icp-sdk/core/agent";
+import type { Principal } from "@icp-sdk/core/principal";
+export declare class SultanaCoreMotokoActor {
+    private canisterId;
+    private actor;
+    private agent;
+    constructor(canisterId: string, identity?: Identity);
+    private initActor;
+    protected executeFunctionAsyncUnsafe<T>(fnAsync: () => Promise<{
+        ok: T;
+    } | {
+        err: any;
+    }>): Promise<T>;
+    protected handleResultErrors(error: any): {
+        errorKey: string;
+        errorMessage: any;
+    };
+    setMyselfAsAdminAsyncUnsafe(): Promise<Principal>;
+    getAdminAsyncUnsafe(): Promise<Principal>;
+}
+//# sourceMappingURL=sultana-core-motoko-actor.d.ts.map

package/dist/sultana-core-motoko-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sultana-core-motoko-actor.d.ts","sourceRoot":"","sources":["../src/sultana-core-motoko-actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAI1F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qBAAa,sBAAsB;IAInB,OAAO,CAAC,UAAU;IAH9B,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAa;gBAEN,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ;IAU3D,OAAO,CAAC,SAAS;cAOD,0BAA0B,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;QAAE,EAAE,EAAE,CAAC,CAAA;KAAE,GAAG;QAAE,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAwB3G,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,GAAG;;;;IAY1B,2BAA2B,IAAI,OAAO,CAAC,SAAS,CAAC;IAMjD,mBAAmB,IAAI,OAAO,CAAC,SAAS,CAAC;CAKzD"}

package/dist/sultana-core-motoko-actor.js

@@ -0,0 +1,55 @@
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+import { Secp256k1KeyIdentity } from "@icp-sdk/core/identity/secp256k1";
+import { idlFactory } from "../declarations/sultana-core-motoko/index.js";
+export class SultanaCoreMotokoActor {
+    constructor(canisterId, identity) {
+        this.canisterId = canisterId;
+        this.agent = HttpAgent.createSync({
+            host: "https://icp0.io",
+            identity: identity
+        });
+        // 2. Inicjalizacja Aktora
+        this.initActor();
+    }
+    initActor() {
+        this.actor = Actor.createActor(idlFactory, {
+            agent: this.agent,
+            canisterId: this.canisterId,
+        });
+    }
+    async executeFunctionAsyncUnsafe(fnAsync) {
+        let errorObj;
+        try {
+            const result = await fnAsync();
+            if ('ok' in result) {
+                return result.ok;
+            }
+            errorObj = this.handleResultErrors(result.err);
+            const fullError = errorObj.errorKey + ': ' + errorObj.errorMessage;
+        }
+        catch (err) {
+            throw new Error("CriticalErrorCanister");
+        }
+        if (errorObj) {
+            throw new Error(errorObj.errorKey);
+        }
+        else {
+            throw new Error("Unreachable code reached OPDIZ");
+        }
+    }
+    handleResultErrors(error) {
+        const errorKey = Object.keys(error)[0];
+        const errorMessage = error[errorKey];
+        return {
+            errorKey: errorKey.toString(),
+            errorMessage
+        };
+    }
+    // --- Public Actor Methods ---
+    async setMyselfAsAdminAsyncUnsafe() {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.setSystemAdmin([]));
+    }
+    async getAdminAsyncUnsafe() {
+        return this.executeFunctionAsyncUnsafe(() => this.actor.getSystemAdmin());
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@jsm-mit/sultana-core-motoko-package",
+    "version": "0.0.1",
+    "description": "A TypeScript library for interacting with the Sultana Core Motoko actor on the Internet Computer (IC) platform.",
+    "homepage": "https://github.com/JSM-Sultana/sultana-core-motoko-package#readme",
+    "bugs": {
+        "url": "https://github.com/JSM-Sultana/sultana-core-motoko-package/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/JSM-Sultana/sultana-core-motoko-package.git"
+    },
+    "license": "ISC",
+    "author": "",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist/",
+        "declarations/"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "clean": "rm -rf dist",
+        "prepare": "npm run build",
+        "publish-public": "npm run build && npm login && npm publish --access public",
+        "test": "vitest",
+        "sandbox": "npx tsx sandbox/main.ts"
+    },
+    "dependencies": {
+        "@icp-sdk/core": "^5.2.0"
+    },
+    "peerDependencies": {
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.2",
+        "@jsm-mit/utils-package": "0.4.1",
+        "dotenv": "^16.3.1",
+        "tsx": "^4.18.0",
+        "vitest": "^1.0.0",
+        "typescript": "^5.9.3"
+    }
+}