@bloque/sdk-orgs 0.0.49 → 0.1.1

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,_)=>{for(var r in _)__webpack_require__.o(_,r)&&!__webpack_require__.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:_[r]})},__webpack_require__.o=(e,_)=>Object.prototype.hasOwnProperty.call(e,_),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{OrgsClient:()=>OrgsClient});const sdk_core_namespaceObject=require("@bloque/sdk-core");class OrgsClient extends sdk_core_namespaceObject.BaseClient{async create(e){return(await this.httpClient.request({method:"POST",path:"/api/orgs",body:e})).result.organization}}for(var __rspack_i in exports.OrgsClient=__webpack_exports__.OrgsClient,__webpack_exports__)-1===["OrgsClient"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,t)=>{for(var s in t)__webpack_require__.o(t,s)&&!__webpack_require__.o(e,s)&&Object.defineProperty(e,s,{enumerable:!0,get:t[s]})},__webpack_require__.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{TeamsClient:()=>TeamsClient,OrgsClient:()=>OrgsClient,InvitesClient:()=>InvitesClient,MembersClient:()=>MembersClient});const sdk_core_namespaceObject=require("@bloque/sdk-core");class MembersClient extends sdk_core_namespaceObject.BaseClient{async update(e,t){let s={title:t.title,display_name:t.displayName,is_public:t.isPublic,org_scopes:t.orgScopes,org_roles:t.orgRoles,metadata:t.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/members/${e}`,body:s})).result.member}async remove(e,t){await this.httpClient.request({method:"DELETE",path:`/api/orgs/${e}/members/${t}`})}}class TeamsClient extends sdk_core_namespaceObject.BaseClient{async list(e){return await this.httpClient.request({method:"GET",path:`/api/orgs/${e}/teams`})}async update(e,t){let s={name:t.name,image_url:t.imageUrl,description:t.description,metadata:t.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/teams/${e}`,body:s})).result.team}async listMembers(e){return await this.httpClient.request({method:"GET",path:`/api/teams/${e}/members`})}async updateMember(e,t,s){let a={team_scopes:s.teamScopes,team_roles:s.teamRoles,metadata:s.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/teams/${e}/members/${t}`,body:a})).result.team_member}async removeMember(e,t){await this.httpClient.request({method:"DELETE",path:`/api/teams/${e}/members/${t}`})}}class InvitesClient extends sdk_core_namespaceObject.BaseClient{async create(e,t){let s={type:t.type,details:t.details,channel:t.channel,channel_routing:t.channelRouting,metadata:t.metadata};return(await this.httpClient.request({method:"POST",path:`/api/orgs/${e}/invite`,body:s})).result.invite}async get(e){return await this.httpClient.request({method:"GET",path:`/api/invite/${e}`})}async list(e={}){let t=new URLSearchParams;e.type&&t.set("type",e.type),e.status&&t.set("status",e.status),e.channel&&t.set("channel",e.channel),e.orgUrn&&t.set("org_urn",e.orgUrn),e.teamUrn&&t.set("team_urn",e.teamUrn),e.fromIdentityUrn&&t.set("from_identity_urn",e.fromIdentityUrn),void 0!==e.limit&&t.set("limit",e.limit.toString()),void 0!==e.offset&&t.set("offset",e.offset.toString()),e.order&&t.set("order",e.order);let s=t.toString(),a=s?`/api/invites?${s}`:"/api/invites";return await this.httpClient.request({method:"GET",path:a})}async accept(e){return(await this.httpClient.request({method:"POST",path:`/api/invite/${e}/accept`})).result.invite}async reject(e,t){return(await this.httpClient.request({method:"POST",path:`/api/invite/${e}/reject`,body:t?{reason:t}:void 0})).result.invite}async resend(e){return(await this.httpClient.request({method:"POST",path:`/api/invite/${e}/resend`})).result.invite}}class OrgsClient extends sdk_core_namespaceObject.BaseClient{members;teams;invites;constructor(e){super(e),this.members=new MembersClient(this.httpClient),this.teams=new TeamsClient(this.httpClient),this.invites=new InvitesClient(this.httpClient)}async create(e){return(await this.httpClient.request({method:"POST",path:"/api/orgs",body:e})).result.organization}async get(e){return await this.httpClient.request({method:"GET",path:`/api/orgs/${e}`})}async list(){return await this.httpClient.request({method:"GET",path:"/api/identities/me/orgs"})}async verifySlug(e){let t=await this.httpClient.request({method:"GET",path:`/api/orgs/verify-slug?slug=${encodeURIComponent(e)}`});return{available:t.available,normalizedSlug:t.normalized_slug,suggestions:t.suggestions}}async listMembers(e){return await this.httpClient.request({method:"GET",path:`/api/orgs/${e}/members`})}async delete(e){await this.httpClient.request({method:"DELETE",path:`/api/orgs/${e}`})}}for(var __rspack_i in exports.InvitesClient=__webpack_exports__.InvitesClient,exports.MembersClient=__webpack_exports__.MembersClient,exports.OrgsClient=__webpack_exports__.OrgsClient,exports.TeamsClient=__webpack_exports__.TeamsClient,__webpack_exports__)-1===["InvitesClient","MembersClient","OrgsClient","TeamsClient"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './orgs-client';
+export { InvitesClient, MembersClient, OrgsClient, TeamsClient, } from './orgs-client';
 export * from './types';

package/dist/index.js

@@ -1 +1 @@
-import{BaseClient as t}from"@bloque/sdk-core";class e extends t{async create(t){return(await this.httpClient.request({method:"POST",path:"/api/orgs",body:t})).result.organization}}export{e as OrgsClient};
+import{BaseClient as t}from"@bloque/sdk-core";class e extends t{async update(t,e){let a={title:e.title,display_name:e.displayName,is_public:e.isPublic,org_scopes:e.orgScopes,org_roles:e.orgRoles,metadata:e.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/members/${t}`,body:a})).result.member}async remove(t,e){await this.httpClient.request({method:"DELETE",path:`/api/orgs/${t}/members/${e}`})}}class a extends t{async list(t){return await this.httpClient.request({method:"GET",path:`/api/orgs/${t}/teams`})}async update(t,e){let a={name:e.name,image_url:e.imageUrl,description:e.description,metadata:e.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/teams/${t}`,body:a})).result.team}async listMembers(t){return await this.httpClient.request({method:"GET",path:`/api/teams/${t}/members`})}async updateMember(t,e,a){let s={team_scopes:a.teamScopes,team_roles:a.teamRoles,metadata:a.metadata};return(await this.httpClient.request({method:"PATCH",path:`/api/teams/${t}/members/${e}`,body:s})).result.team_member}async removeMember(t,e){await this.httpClient.request({method:"DELETE",path:`/api/teams/${t}/members/${e}`})}}class s extends t{async create(t,e){let a={type:e.type,details:e.details,channel:e.channel,channel_routing:e.channelRouting,metadata:e.metadata};return(await this.httpClient.request({method:"POST",path:`/api/orgs/${t}/invite`,body:a})).result.invite}async get(t){return await this.httpClient.request({method:"GET",path:`/api/invite/${t}`})}async list(t={}){let e=new URLSearchParams;t.type&&e.set("type",t.type),t.status&&e.set("status",t.status),t.channel&&e.set("channel",t.channel),t.orgUrn&&e.set("org_urn",t.orgUrn),t.teamUrn&&e.set("team_urn",t.teamUrn),t.fromIdentityUrn&&e.set("from_identity_urn",t.fromIdentityUrn),void 0!==t.limit&&e.set("limit",t.limit.toString()),void 0!==t.offset&&e.set("offset",t.offset.toString()),t.order&&e.set("order",t.order);let a=e.toString(),s=a?`/api/invites?${a}`:"/api/invites";return await this.httpClient.request({method:"GET",path:s})}async accept(t){return(await this.httpClient.request({method:"POST",path:`/api/invite/${t}/accept`})).result.invite}async reject(t,e){return(await this.httpClient.request({method:"POST",path:`/api/invite/${t}/reject`,body:e?{reason:e}:void 0})).result.invite}async resend(t){return(await this.httpClient.request({method:"POST",path:`/api/invite/${t}/resend`})).result.invite}}class i extends t{members;teams;invites;constructor(t){super(t),this.members=new e(this.httpClient),this.teams=new a(this.httpClient),this.invites=new s(this.httpClient)}async create(t){return(await this.httpClient.request({method:"POST",path:"/api/orgs",body:t})).result.organization}async get(t){return await this.httpClient.request({method:"GET",path:`/api/orgs/${t}`})}async list(){return await this.httpClient.request({method:"GET",path:"/api/identities/me/orgs"})}async verifySlug(t){let e=await this.httpClient.request({method:"GET",path:`/api/orgs/verify-slug?slug=${encodeURIComponent(t)}`});return{available:e.available,normalizedSlug:e.normalized_slug,suggestions:e.suggestions}}async listMembers(t){return await this.httpClient.request({method:"GET",path:`/api/orgs/${t}/members`})}async delete(t){await this.httpClient.request({method:"DELETE",path:`/api/orgs/${t}`})}}export{s as InvitesClient,e as MembersClient,i as OrgsClient,a as TeamsClient};

package/dist/internal/wire-types.d.ts

@@ -74,3 +74,219 @@ export interface CreateOrgResponse {
     };
     req_id: string;
 }
+/**
+ * @internal
+ * Get organization response
+ */
+export interface GetOrgResponse extends Organization {
+}
+/**
+ * @internal
+ * List user organizations response
+ */
+export type ListUserOrgsResponse = Organization[];
+/**
+ * @internal
+ * Verify slug availability response
+ */
+export interface VerifySlugResponse {
+    available: boolean;
+    normalized_slug: string;
+    suggestions?: string[];
+}
+/**
+ * @internal
+ * Organization member
+ */
+export interface Member {
+    urn: string;
+    org_urn: string;
+    is_public: boolean;
+    title: string;
+    display_name: string;
+    identity_urn: string;
+    org_scopes: string[];
+    org_roles: string[];
+    metadata: Record<string, string>;
+}
+/**
+ * @internal
+ * List organization members response
+ */
+export type ListMembersResponse = Member[];
+/**
+ * @internal
+ * Update member request
+ */
+export interface UpdateMemberRequest {
+    title?: string;
+    display_name?: string;
+    is_public?: boolean;
+    org_scopes?: string[];
+    org_roles?: string[];
+    metadata?: Record<string, string>;
+}
+/**
+ * @internal
+ * Update member response
+ */
+export interface UpdateMemberResponse {
+    result: {
+        member: Member;
+    };
+    req_id: string;
+}
+/**
+ * @internal
+ * Team
+ */
+export interface Team {
+    urn: string;
+    org_urn: string;
+    name: string;
+    image_url: string;
+    description: string;
+    metadata: Record<string, string>;
+}
+/**
+ * @internal
+ * List teams response
+ */
+export type ListTeamsResponse = Team[];
+/**
+ * @internal
+ * Update team request
+ */
+export interface UpdateTeamRequest {
+    name?: string;
+    image_url?: string;
+    description?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * @internal
+ * Update team response
+ */
+export interface UpdateTeamResponse {
+    result: {
+        team: Team;
+    };
+    req_id: string;
+}
+/**
+ * @internal
+ * Team member
+ */
+export interface TeamMember {
+    team_urn: string;
+    member_urn: string;
+    team_scopes: string[];
+    team_roles: string[];
+    metadata: Record<string, string>;
+}
+/**
+ * @internal
+ * List team members response
+ */
+export type ListTeamMembersResponse = TeamMember[];
+/**
+ * @internal
+ * Update team member request
+ */
+export interface UpdateTeamMemberRequest {
+    team_scopes?: string[];
+    team_roles?: string[];
+    metadata?: Record<string, string>;
+}
+/**
+ * @internal
+ * Update team member response
+ */
+export interface UpdateTeamMemberResponse {
+    result: {
+        team_member: TeamMember;
+    };
+    req_id: string;
+}
+/**
+ * @internal
+ * Invite type
+ */
+export type InviteType = 'member' | 'team';
+/**
+ * @internal
+ * Invite status
+ */
+export type InviteStatus = 'pending' | 'accepted' | 'rejected' | 'expired' | 'cancelled';
+/**
+ * @internal
+ * Invite channel
+ */
+export type InviteChannel = 'email' | 'sms' | 'whatsapp' | 'identity';
+/**
+ * @internal
+ * Invite
+ */
+export interface Invite {
+    code: string;
+    org_urn: string;
+    org_info: {
+        name: string;
+        logo_url: string;
+    };
+    sender_member_urn: string;
+    sender_info: {
+        identity_urn: string;
+        name?: string;
+        email?: string;
+        phone?: string;
+    };
+    type: InviteType;
+    details: Record<string, unknown>;
+    channel: InviteChannel;
+    channel_routing: Record<string, string>;
+    metadata: Record<string, string>;
+    status: InviteStatus;
+    member_urn?: string;
+}
+/**
+ * @internal
+ * Create invite request
+ */
+export interface CreateInviteRequest {
+    type: InviteType;
+    details: Record<string, unknown>;
+    channel: InviteChannel;
+    channel_routing: Record<string, string>;
+    metadata?: Record<string, string>;
+}
+/**
+ * @internal
+ * Create invite response
+ */
+export interface CreateInviteResponse {
+    result: {
+        invite: Invite;
+    };
+    req_id: string;
+}
+/**
+ * @internal
+ * List invites response (paginated)
+ */
+export interface ListInvitesResponse {
+    data: Invite[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * @internal
+ * Invite action response (accept, reject, resend)
+ */
+export interface InviteActionResponse {
+    result: {
+        invite: Invite;
+    };
+    req_id: string;
+}

package/dist/orgs-client.d.ts

@@ -1,5 +1,153 @@
+import type { HttpClient } from '@bloque/sdk-core';
 import { BaseClient } from '@bloque/sdk-core';
-import type { CreateOrgParams, Organization } from './types';
+import type { Invite, Member, Team, TeamMember } from './internal/wire-types';
+import type { CreateInviteParams, CreateOrgParams, ListInvitesParams, ListInvitesResult, Organization, UpdateMemberParams, UpdateTeamMemberParams, UpdateTeamParams, VerifySlugResult } from './types';
+export declare class MembersClient extends BaseClient {
+    /**
+     * Update an organization member
+     *
+     * @param memberUrn - Member URN
+     * @param params - Fields to update
+     * @returns Updated member
+     */
+    update(memberUrn: string, params: UpdateMemberParams): Promise<Member>;
+    /**
+     * Remove a member from an organization
+     *
+     * @param orgUrn - Organization URN
+     * @param memberUrn - Member URN to remove
+     */
+    remove(orgUrn: string, memberUrn: string): Promise<void>;
+}
+export declare class TeamsClient extends BaseClient {
+    /**
+     * List teams in an organization
+     *
+     * @param orgUrn - Organization URN
+     * @returns Array of teams
+     */
+    list(orgUrn: string): Promise<Team[]>;
+    /**
+     * Update a team
+     *
+     * @param teamUrn - Team URN
+     * @param params - Fields to update
+     * @returns Updated team
+     */
+    update(teamUrn: string, params: UpdateTeamParams): Promise<Team>;
+    /**
+     * List members of a team
+     *
+     * @param teamUrn - Team URN
+     * @returns Array of team members
+     */
+    listMembers(teamUrn: string): Promise<TeamMember[]>;
+    /**
+     * Update a team member's roles and scopes
+     *
+     * @param teamUrn - Team URN
+     * @param memberUrn - Member URN
+     * @param params - Fields to update
+     * @returns Updated team member
+     */
+    updateMember(teamUrn: string, memberUrn: string, params: UpdateTeamMemberParams): Promise<TeamMember>;
+    /**
+     * Remove a member from a team
+     *
+     * @param teamUrn - Team URN
+     * @param memberUrn - Member URN
+     */
+    removeMember(teamUrn: string, memberUrn: string): Promise<void>;
+}
+export declare class InvitesClient extends BaseClient {
+    /**
+     * Create an invite to an organization
+     *
+     * @param orgUrn - Organization URN
+     * @param params - Invite details
+     * @returns Created invite
+     */
+    create(orgUrn: string, params: CreateInviteParams): Promise<Invite>;
+    /**
+     * Get an invite by code
+     *
+     * @param code - Invite code
+     * @returns Invite details
+     */
+    get(code: string): Promise<Invite>;
+    /**
+     * List invites with optional filters
+     *
+     * @param params - Filter and pagination parameters
+     * @returns Paginated list of invites
+     */
+    list(params?: ListInvitesParams): Promise<ListInvitesResult>;
+    /**
+     * Accept an invite
+     *
+     * @param code - Invite code
+     * @returns Updated invite
+     */
+    accept(code: string): Promise<Invite>;
+    /**
+     * Reject an invite
+     *
+     * @param code - Invite code
+     * @param reason - Optional rejection reason
+     * @returns Updated invite
+     */
+    reject(code: string, reason?: string): Promise<Invite>;
+    /**
+     * Resend an invite
+     *
+     * @param code - Invite code
+     * @returns Updated invite
+     */
+    resend(code: string): Promise<Invite>;
+}
 export declare class OrgsClient extends BaseClient {
+    readonly members: MembersClient;
+    readonly teams: TeamsClient;
+    readonly invites: InvitesClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Create a new organization
+     *
+     * @param params - Organization creation parameters
+     * @returns Created organization
+     */
     create(params: CreateOrgParams): Promise<Organization>;
+    /**
+     * Get organization by URN
+     *
+     * @param orgUrn - Organization URN
+     * @returns Organization details
+     */
+    get(orgUrn: string): Promise<Organization>;
+    /**
+     * List organizations the current user belongs to
+     *
+     * @returns Array of organizations
+     */
+    list(): Promise<Organization[]>;
+    /**
+     * Verify if an organization slug is available
+     *
+     * @param slug - Slug to verify
+     * @returns Slug availability and suggestions
+     */
+    verifySlug(slug: string): Promise<VerifySlugResult>;
+    /**
+     * List members of an organization
+     *
+     * @param orgUrn - Organization URN
+     * @returns Array of members
+     */
+    listMembers(orgUrn: string): Promise<Member[]>;
+    /**
+     * Delete an organization
+     *
+     * @param orgUrn - Organization URN
+     */
+    delete(orgUrn: string): Promise<void>;
 }

package/dist/types.d.ts

@@ -1,5 +1,73 @@
 /**
  * Public types for @bloque/sdk-orgs
- * Re-exports internal wire types for backward compatibility
  */
-export type { CreateOrgParams, CreateOrgResponse, Organization, OrgProfile, OrgStatus, OrgType, Place, } from './internal/wire-types';
+export type { CreateOrgParams, CreateOrgResponse, Invite, InviteChannel, InviteStatus, InviteType, Member, Organization, OrgProfile, OrgStatus, OrgType, Place, Team, TeamMember, } from './internal/wire-types';
+/**
+ * Result of verifying slug availability
+ */
+export interface VerifySlugResult {
+    available: boolean;
+    normalizedSlug: string;
+    suggestions?: string[];
+}
+/**
+ * Parameters for listing invites
+ */
+export interface ListInvitesParams {
+    type?: 'member' | 'team';
+    status?: 'pending' | 'accepted' | 'rejected' | 'expired' | 'cancelled';
+    channel?: 'email' | 'sms' | 'whatsapp' | 'identity';
+    orgUrn?: string;
+    teamUrn?: string;
+    fromIdentityUrn?: string;
+    limit?: number;
+    offset?: number;
+    order?: 'asc' | 'desc';
+}
+/**
+ * Paginated invite list result
+ */
+export interface ListInvitesResult {
+    data: import('./internal/wire-types').Invite[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * Parameters for creating an invite
+ */
+export interface CreateInviteParams {
+    type: 'member' | 'team';
+    details: Record<string, unknown>;
+    channel: 'email' | 'sms' | 'whatsapp' | 'identity';
+    channelRouting: Record<string, string>;
+    metadata?: Record<string, string>;
+}
+/**
+ * Parameters for updating a member
+ */
+export interface UpdateMemberParams {
+    title?: string;
+    displayName?: string;
+    isPublic?: boolean;
+    orgScopes?: string[];
+    orgRoles?: string[];
+    metadata?: Record<string, string>;
+}
+/**
+ * Parameters for updating a team
+ */
+export interface UpdateTeamParams {
+    name?: string;
+    imageUrl?: string;
+    description?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * Parameters for updating a team member
+ */
+export interface UpdateTeamMemberParams {
+    teamScopes?: string[];
+    teamRoles?: string[];
+    metadata?: Record<string, string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloque/sdk-orgs",
-  "version": "0.0.49",
+  "version": "0.1.1",
   "type": "module",
   "keywords": [
     "bloque",