admin

package
v0.1.0-beta.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 30, 2025 License: MIT Imports: 18 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessEntity 

type AccessEntity struct {
	// Entity category such as item.
	Category *Category

	// Entity name.
	DisplayName *string

	// Item permissions.
	ItemAccessDetails *ItemAccessDetail

	// Entity type.
	Type *string

	// READ-ONLY; The object ID of the entity.
	ID *string
}

AccessEntity - Access details for the given user.

func (AccessEntity) MarshalJSON 

func (a AccessEntity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccessEntity.

func (*AccessEntity) UnmarshalJSON 

func (a *AccessEntity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccessEntity.

type AccessEntityResponse 

type AccessEntityResponse struct {
	// A list of users with access to an entity.
	AccessEntities []AccessEntity

	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string
}

AccessEntityResponse - A list of entities and permissions.

func (AccessEntityResponse) MarshalJSON 

func (a AccessEntityResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccessEntityResponse.

func (*AccessEntityResponse) UnmarshalJSON 

func (a *AccessEntityResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccessEntityResponse.

type AssignDomainWorkspacesByCapacitiesRequest 

type AssignDomainWorkspacesByCapacitiesRequest struct {
	// The capacity IDs.
	CapacitiesIDs []string
}

AssignDomainWorkspacesByCapacitiesRequest - The request payload for assigning workspaces to a domain by capacity.

func (AssignDomainWorkspacesByCapacitiesRequest) MarshalJSON 

func (a AssignDomainWorkspacesByCapacitiesRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AssignDomainWorkspacesByCapacitiesRequest.

func (*AssignDomainWorkspacesByCapacitiesRequest) UnmarshalJSON 

func (a *AssignDomainWorkspacesByCapacitiesRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AssignDomainWorkspacesByCapacitiesRequest.

type AssignDomainWorkspacesByIDsRequest 

type AssignDomainWorkspacesByIDsRequest struct {
	WorkspacesIDs []string
}

AssignDomainWorkspacesByIDsRequest - The request payload for assigning workspaces to a domain by workspace ID.

func (AssignDomainWorkspacesByIDsRequest) MarshalJSON 

func (a AssignDomainWorkspacesByIDsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AssignDomainWorkspacesByIDsRequest.

func (*AssignDomainWorkspacesByIDsRequest) UnmarshalJSON 

func (a *AssignDomainWorkspacesByIDsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AssignDomainWorkspacesByIDsRequest.

type AssignDomainWorkspacesByPrincipalsRequest 

type AssignDomainWorkspacesByPrincipalsRequest struct {
	Principals []Principal
}

AssignDomainWorkspacesByPrincipalsRequest - The request payload for assigning workspaces to a domain by principal.

func (AssignDomainWorkspacesByPrincipalsRequest) MarshalJSON 

func (a AssignDomainWorkspacesByPrincipalsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AssignDomainWorkspacesByPrincipalsRequest.

func (*AssignDomainWorkspacesByPrincipalsRequest) UnmarshalJSON 

func (a *AssignDomainWorkspacesByPrincipalsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AssignDomainWorkspacesByPrincipalsRequest.

type AssignmentMethod 

type AssignmentMethod string

AssignmentMethod - Specifies whether the assigned label was set by an automated process or manually. Additional tenant setting property types may be added over time. 

const (
	// AssignmentMethodPriviledged - The label was set manually.
	AssignmentMethodPriviledged AssignmentMethod = "Priviledged"
	// AssignmentMethodStandard - The label was set by an automated process (default value).
	AssignmentMethodStandard AssignmentMethod = "Standard"
)

func PossibleAssignmentMethodValues 

func PossibleAssignmentMethodValues() []AssignmentMethod

PossibleAssignmentMethodValues returns the possible values for the AssignmentMethod const type.

type AzureDevOpsDetails 

type AzureDevOpsDetails struct {
	// REQUIRED; The branch name. Maximum length is 250 characters.
	BranchName *string

	// REQUIRED; The relative path to the directory. Maximum length is 256 characters.
	DirectoryName *string

	// REQUIRED; A Git provider type. Additional provider types may be added over time.
	GitProviderType *GitProviderType

	// REQUIRED; The organization name. Maximum length is 100 characters.
	OrganizationName *string

	// REQUIRED; The project name. Maximum length is 100 characters.
	ProjectName *string

	// REQUIRED; The repository name. Maximum length is 128 characters.
	RepositoryName *string
}

AzureDevOpsDetails - Azure DevOps provider details.

func (*AzureDevOpsDetails) GetGitProviderDetails 

func (a *AzureDevOpsDetails) GetGitProviderDetails() *GitProviderDetails

GetGitProviderDetails implements the GitProviderDetailsClassification interface for type AzureDevOpsDetails.

func (AzureDevOpsDetails) MarshalJSON 

func (a AzureDevOpsDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureDevOpsDetails.

func (*AzureDevOpsDetails) UnmarshalJSON 

func (a *AzureDevOpsDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureDevOpsDetails.

type Category 

type Category string

Category - The category of the item type. Additional category types may be added over time. 

const (
	// CategoryItem - Fabric items such as Notebook, Synapse and KQL Database.
	CategoryItem Category = "Item"
)

func PossibleCategoryValues 

func PossibleCategoryValues() []Category

PossibleCategoryValues returns the possible values for the Category const type.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(credential azcore.TokenCredential, endpoint *string, options *azcore.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • endpoint - pass nil to accept the default values.
  • options - pass nil to accept the default values.

func NewClientFactoryWithClient 

func NewClientFactoryWithClient(client fabric.Client) *ClientFactory

NewClientFactoryWithClient creates a new instance of ClientFactory with sharable Client. The Client will be propagated to any client created from this factory.

  • client - Client created in the containing module: github.com/microsoft/fabric-sdk-go/fabric

func (*ClientFactory) NewDomainsClient 

func (c *ClientFactory) NewDomainsClient() *DomainsClient

NewDomainsClient creates a new instance of DomainsClient.

func (*ClientFactory) NewExternalDataSharesClient 

func (c *ClientFactory) NewExternalDataSharesClient() *ExternalDataSharesClient

NewExternalDataSharesClient creates a new instance of ExternalDataSharesClient.

func (*ClientFactory) NewItemsClient 

func (c *ClientFactory) NewItemsClient() *ItemsClient

NewItemsClient creates a new instance of ItemsClient.

func (*ClientFactory) NewLabelsClient 

func (c *ClientFactory) NewLabelsClient() *LabelsClient

NewLabelsClient creates a new instance of LabelsClient.

func (*ClientFactory) NewTenantsClient 

func (c *ClientFactory) NewTenantsClient() *TenantsClient

NewTenantsClient creates a new instance of TenantsClient.

func (*ClientFactory) NewUsersClient 

func (c *ClientFactory) NewUsersClient() *UsersClient

NewUsersClient creates a new instance of UsersClient.

func (*ClientFactory) NewWorkspacesClient 

func (c *ClientFactory) NewWorkspacesClient() *WorkspacesClient

NewWorkspacesClient creates a new instance of WorkspacesClient.

type ContributorsScopeType 

type ContributorsScopeType string

ContributorsScopeType - The contributor scope. Additional contributor scopes may be added over time. 

const (
	// ContributorsScopeTypeAdminsOnly - Tenant and domain admins only.
	ContributorsScopeTypeAdminsOnly ContributorsScopeType = "AdminsOnly"
	// ContributorsScopeTypeAllTenant - All the tenant's users.
	ContributorsScopeTypeAllTenant ContributorsScopeType = "AllTenant"
	// ContributorsScopeTypeSpecificUsersAndGroups - Specific users and groups.
	ContributorsScopeTypeSpecificUsersAndGroups ContributorsScopeType = "SpecificUsersAndGroups"
)

func PossibleContributorsScopeTypeValues 

func PossibleContributorsScopeTypeValues() []ContributorsScopeType

PossibleContributorsScopeTypeValues returns the possible values for the ContributorsScopeType const type.

type CreateDomainRequest 

type CreateDomainRequest struct {
	// REQUIRED; The domain display name. The display name cannot contain more than 40 characters.
	DisplayName *string

	// The domain description. The description cannot contain more than 256 characters.
	Description *string

	// The domain parent object ID.
	ParentDomainID *string
}

CreateDomainRequest - The request payload for creating a domain or subdomain.

func (CreateDomainRequest) MarshalJSON 

func (c CreateDomainRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CreateDomainRequest.

func (*CreateDomainRequest) UnmarshalJSON 

func (c *CreateDomainRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CreateDomainRequest.

type DelegatedFrom 

type DelegatedFrom string

DelegatedFrom - The Fabric component (workspace, capacity or domain) that the tenant setting was delegated from. Additional DelegatedFrom may be added over time. 

const (
	// DelegatedFromCapacity - The setting is delegated from a capacity.
	DelegatedFromCapacity DelegatedFrom = "Capacity"
	// DelegatedFromDomain - The setting is delegated from a domain.
	DelegatedFromDomain DelegatedFrom = "Domain"
	// DelegatedFromTenant - The setting is delegated from a tenant.
	DelegatedFromTenant DelegatedFrom = "Tenant"
)

func PossibleDelegatedFromValues 

func PossibleDelegatedFromValues() []DelegatedFrom

PossibleDelegatedFromValues returns the possible values for the DelegatedFrom const type.

type Domain 

type Domain struct {
	// REQUIRED; The domain contributors scope.
	ContributorsScope *ContributorsScopeType

	// REQUIRED; The name of the domain.
	DisplayName *string

	// REQUIRED; The domain object ID.
	ID *string

	// The description of the domain.
	Description *string

	// The domain parent object ID.
	ParentDomainID *string
}

Domain - Represents a domain or subdomain.

func (Domain) MarshalJSON 

func (d Domain) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Domain.

func (*Domain) UnmarshalJSON 

func (d *Domain) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Domain.

type DomainRole 

type DomainRole string

DomainRole - Represents the domain members by the principal's request type. Additional request types may be added over time. 

const (
	// DomainRoleAdmins - Domain admins request type.
	DomainRoleAdmins DomainRole = "Admins"
	// DomainRoleContributors - Domain contributors request type.
	DomainRoleContributors DomainRole = "Contributors"
)

func PossibleDomainRoleValues 

func PossibleDomainRoleValues() []DomainRole

PossibleDomainRoleValues returns the possible values for the DomainRole const type.

type DomainRoleAssignmentRequest 

type DomainRoleAssignmentRequest struct {
	// REQUIRED; The update request type.
	Type       *DomainRole
	Principals []Principal
}

DomainRoleAssignmentRequest - The request payload for assigning domain members for a domain by principal.

func (DomainRoleAssignmentRequest) MarshalJSON 

func (d DomainRoleAssignmentRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainRoleAssignmentRequest.

func (*DomainRoleAssignmentRequest) UnmarshalJSON 

func (d *DomainRoleAssignmentRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainRoleAssignmentRequest.

type DomainRoleUnassignmentRequest 

type DomainRoleUnassignmentRequest struct {
	// REQUIRED; The update request type.
	Type       *DomainRole
	Principals []Principal
}

DomainRoleUnassignmentRequest - The request payload for unassigning domain members by principal.

func (DomainRoleUnassignmentRequest) MarshalJSON 

func (d DomainRoleUnassignmentRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainRoleUnassignmentRequest.

func (*DomainRoleUnassignmentRequest) UnmarshalJSON 

func (d *DomainRoleUnassignmentRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainRoleUnassignmentRequest.

type DomainWorkspace 

type DomainWorkspace struct {
	// REQUIRED; The name of the workspace.
	DisplayName *string

	// REQUIRED; The workspace ID.
	ID *string
}

DomainWorkspace - Represents a workspace in a domain.

func (DomainWorkspace) MarshalJSON 

func (d DomainWorkspace) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainWorkspace.

func (*DomainWorkspace) UnmarshalJSON 

func (d *DomainWorkspace) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainWorkspace.

type DomainWorkspaces 

type DomainWorkspaces struct {
	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string

	// The list of all the workspaces assigned to the domain.
	Value []DomainWorkspace
}

DomainWorkspaces - A response wrapper for a list of all the workspaces assigned to a domain with a continuous token.

func (DomainWorkspaces) MarshalJSON 

func (d DomainWorkspaces) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainWorkspaces.

func (*DomainWorkspaces) UnmarshalJSON 

func (d *DomainWorkspaces) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainWorkspaces.

type DomainsClient 

type DomainsClient struct {
	// contains filtered or unexported fields
}

DomainsClient contains the methods for the Domains group. Don't use this type directly, use a constructor function instead.

func (*DomainsClient) AssignDomainWorkspacesByCapacities 

func (client *DomainsClient) AssignDomainWorkspacesByCapacities(ctx context.Context, domainID string, assignDomainWorkspacesByCapacitiesRequest AssignDomainWorkspacesByCapacitiesRequest, options *DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions) (DomainsClientAssignDomainWorkspacesByCapacitiesResponse, error)

AssignDomainWorkspacesByCapacities - returns DomainsClientAssignDomainWorkspacesByCapacitiesResponse in sync mode. Preexisting domain assignments will be overridden unless bulk reassignment is blocked by domain management tenant settings.

This API supports long running operations (LRO) [/rest/api/fabric/articles/long-running-operation].

PERMISSIONS The caller must be a Fabric administrator.

REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All.

LIMITATIONS Maximum 10 requests per one minute per principal.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No |

INTERFACE Generated from API version v1

  • domainID - The domain ID.
  • assignDomainWorkspacesByCapacitiesRequest - The request payload for assigning workspaces to the domain by capacity.
  • options - DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByCapacities method.

func (*DomainsClient) AssignDomainWorkspacesByIDs 

func (client *DomainsClient) AssignDomainWorkspacesByIDs(ctx context.Context, domainID string, assignDomainWorkspacesByIDsRequest AssignDomainWorkspacesByIDsRequest, options *DomainsClientAssignDomainWorkspacesByIDsOptions) (DomainsClientAssignDomainWorkspacesByIDsResponse, error)

AssignDomainWorkspacesByIDs - Preexisting domain assignments will be overridden unless bulk reassignment is blocked by domain management tenant settings. PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 10 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • assignDomainWorkspacesByIDsRequest - The request payload for assigning workspaces to the domain by workspace ID.
  • options - DomainsClientAssignDomainWorkspacesByIDsOptions contains the optional parameters for the DomainsClient.AssignDomainWorkspacesByIDs method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().AssignDomainWorkspacesByIDs(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.AssignDomainWorkspacesByIDsRequest{
		WorkspacesIDs: []string{
			"e8de1852-7382-480a-8404-d5b1f5e1ab65",
			"5348d3a9-c096-4074-9083-09e3ca69c8e5",
			"ac561643-c5c5-4cf1-868e-8755a90e6fa3"},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) AssignDomainWorkspacesByPrincipals 

func (client *DomainsClient) AssignDomainWorkspacesByPrincipals(ctx context.Context, domainID string, assignDomainWorkspacesByPrincipalsRequest AssignDomainWorkspacesByPrincipalsRequest, options *DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions) (DomainsClientAssignDomainWorkspacesByPrincipalsResponse, error)

AssignDomainWorkspacesByPrincipals - returns DomainsClientAssignDomainWorkspacesByPrincipalsResponse in sync mode. Preexisting domain assignments will be overridden unless bulk reassignment is blocked by domain management tenant settings.

This API supports long running operations (LRO) [/rest/api/fabric/articles/long-running-operation].

PERMISSIONS The caller must be a Fabric administrator.

REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All.

LIMITATIONS Maximum 10 requests per one minute per principal.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No |

INTERFACE Generated from API version v1

  • domainID - The domain ID.
  • assignDomainWorkspacesByPrincipalsRequest - The request payload for assigning workspaces to the domain by principal.
  • options - DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByPrincipals method.

func (*DomainsClient) BeginAssignDomainWorkspacesByCapacities 

func (client *DomainsClient) BeginAssignDomainWorkspacesByCapacities(ctx context.Context, domainID string, assignDomainWorkspacesByCapacitiesRequest AssignDomainWorkspacesByCapacitiesRequest, options *DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions) (*runtime.Poller[DomainsClientAssignDomainWorkspacesByCapacitiesResponse], error)

BeginAssignDomainWorkspacesByCapacities - Preexisting domain assignments will be overridden unless bulk reassignment is blocked by domain management tenant settings. This API supports long running operations (LRO) [/rest/api/fabric/articles/long-running-operation]. PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 10 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • assignDomainWorkspacesByCapacitiesRequest - The request payload for assigning workspaces to the domain by capacity.
  • options - DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByCapacities method.

func (*DomainsClient) BeginAssignDomainWorkspacesByPrincipals 

func (client *DomainsClient) BeginAssignDomainWorkspacesByPrincipals(ctx context.Context, domainID string, assignDomainWorkspacesByPrincipalsRequest AssignDomainWorkspacesByPrincipalsRequest, options *DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions) (*runtime.Poller[DomainsClientAssignDomainWorkspacesByPrincipalsResponse], error)

BeginAssignDomainWorkspacesByPrincipals - Preexisting domain assignments will be overridden unless bulk reassignment is blocked by domain management tenant settings. This API supports long running operations (LRO) [/rest/api/fabric/articles/long-running-operation]. PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 10 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • assignDomainWorkspacesByPrincipalsRequest - The request payload for assigning workspaces to the domain by principal.
  • options - DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByPrincipals method.

func (*DomainsClient) CreateDomain 

func (client *DomainsClient) CreateDomain(ctx context.Context, createDomainRequest CreateDomainRequest, options *DomainsClientCreateDomainOptions) (DomainsClientCreateDomainResponse, error)

CreateDomain - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • createDomainRequest - The request payload for creating the domain.
  • options - DomainsClientCreateDomainOptions contains the optional parameters for the DomainsClient.CreateDomain method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().CreateDomain(ctx, admin.CreateDomainRequest{
		Description:    to.Ptr("This domain is used for identifying financial data and reports."),
		DisplayName:    to.Ptr("Finance"),
		ParentDomainID: to.Ptr("5f6552c3-816c-43e7-8289-842f8b35f9df"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) DeleteDomain 

func (client *DomainsClient) DeleteDomain(ctx context.Context, domainID string, options *DomainsClientDeleteDomainOptions) (DomainsClientDeleteDomainResponse, error)

DeleteDomain - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientDeleteDomainOptions contains the optional parameters for the DomainsClient.DeleteDomain method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().DeleteDomain(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) GetDomain 

func (client *DomainsClient) GetDomain(ctx context.Context, domainID string, options *DomainsClientGetDomainOptions) (DomainsClientGetDomainResponse, error)

GetDomain - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientGetDomainOptions contains the optional parameters for the DomainsClient.GetDomain method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDomainsClient().GetDomain(ctx, "f2f6a374-789e-4d1d-9cc7-6e0b934fc529", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Domain = admin.Domain{
	// 	Description: to.Ptr("This domain is used for identifying financial data and reports."),
	// 	ContributorsScope: to.Ptr(admin.ContributorsScopeTypeSpecificUsersAndGroups),
	// 	DisplayName: to.Ptr("Finance"),
	// 	ID: to.Ptr("f2f6a374-789e-4d1d-9cc7-6e0b934fc529"),
	// }
}

Output:

func (*DomainsClient) ListDomainWorkspaces 

func (client *DomainsClient) ListDomainWorkspaces(ctx context.Context, domainID string, options *DomainsClientListDomainWorkspacesOptions) ([]DomainWorkspace, error)

ListDomainWorkspaces - returns array of DomainWorkspace from all pages. This API supports pagination [/rest/api/fabric/articles/pagination].

PERMISSIONS The caller must be a Fabric administrator.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All.

LIMITATIONS Maximum 25 requests per one minute per principal.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientListDomainWorkspacesOptions contains the optional parameters for the DomainsClient.NewListDomainWorkspacesPager method.

func (*DomainsClient) ListDomains 

func (client *DomainsClient) ListDomains(ctx context.Context, options *DomainsClientListDomainsOptions) (DomainsClientListDomainsResponse, error)

ListDomains - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • options - DomainsClientListDomainsOptions contains the optional parameters for the DomainsClient.ListDomains method.
Example (GetAllNonEmptyDomainsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDomainsClient().ListDomains(ctx, &admin.DomainsClientListDomainsOptions{NonEmptyOnly: to.Ptr(true)})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DomainsResponse = admin.DomainsResponse{
	// 	Domains: []admin.Domain{
	// 		{
	// 			Description: to.Ptr("This domain is used for identifying financial data and reports."),
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAdminsOnly),
	// 			DisplayName: to.Ptr("Finance"),
	// 			ID: to.Ptr("bc23d4c6-cc92-4eb6-bcb5-0ff98429bbff"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("Human resources"),
	// 			ID: to.Ptr("b0bca781-003c-4041-b1c4-f94d34ba76d4"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("HR Sales"),
	// 			ID: to.Ptr("6af5a1b6-bc4c-4c0a-b60d-30c68e6e3034"),
	// 			ParentDomainID: to.Ptr("bc23d4c6-cc92-4eb6-bcb5-0ff98429bbff"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeSpecificUsersAndGroups),
	// 			DisplayName: to.Ptr("Marketing"),
	// 			ID: to.Ptr("6c00e8eb-51d4-46f7-8b90-7e98520ea7a0"),
	// 	}},
	// }
}

Output:
Example (GetInfoForAllDomainsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDomainsClient().ListDomains(ctx, &admin.DomainsClientListDomainsOptions{NonEmptyOnly: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DomainsResponse = admin.DomainsResponse{
	// 	Domains: []admin.Domain{
	// 		{
	// 			Description: to.Ptr("This domain is used for identifying financial data and reports."),
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAdminsOnly),
	// 			DisplayName: to.Ptr("Finance"),
	// 			ID: to.Ptr("bc23d4c6-cc92-4eb6-bcb5-0ff98429bbff"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("Human resources"),
	// 			ID: to.Ptr("b0bca781-003c-4041-b1c4-f94d34ba76d4"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("HR Sales"),
	// 			ID: to.Ptr("6af5a1b6-bc4c-4c0a-b60d-30c68e6e3034"),
	// 			ParentDomainID: to.Ptr("bc23d4c6-cc92-4eb6-bcb5-0ff98429bbff"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeSpecificUsersAndGroups),
	// 			DisplayName: to.Ptr("Marketing"),
	// 			ID: to.Ptr("6c00e8eb-51d4-46f7-8b90-7e98520ea7a0"),
	// 		},
	// 		{
	// 			Description: to.Ptr("Admins only"),
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("AdminsOnly"),
	// 			ID: to.Ptr("17df435d-9efd-48c1-a937-7d6fd70ab26a"),
	// 			ParentDomainID: to.Ptr("f2f6a374-789e-4d1d-9cc7-6e0b934fc529"),
	// 		},
	// 		{
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("Root"),
	// 			ID: to.Ptr("fb765fe3-d404-4f24-9d67-5916449c4c50"),
	// 		},
	// 		{
	// 			Description: to.Ptr("This domain is used for identifying legal data and reports."),
	// 			ContributorsScope: to.Ptr(admin.ContributorsScopeTypeAllTenant),
	// 			DisplayName: to.Ptr("Legal"),
	// 			ID: to.Ptr("bda31be4-7efe-4272-8b85-e1b2ff0f0592"),
	// 	}},
	// }
}

Output:

func (*DomainsClient) NewListDomainWorkspacesPager 

func (client *DomainsClient) NewListDomainWorkspacesPager(domainID string, options *DomainsClientListDomainWorkspacesOptions) *runtime.Pager[DomainsClientListDomainWorkspacesResponse]

NewListDomainWorkspacesPager - This API supports pagination [/rest/api/fabric/articles/pagination]. PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientListDomainWorkspacesOptions contains the optional parameters for the DomainsClient.NewListDomainWorkspacesPager method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDomainsClient().NewListDomainWorkspacesPager("97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", &admin.DomainsClientListDomainWorkspacesOptions{ContinuationToken: nil})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DomainWorkspaces = admin.DomainWorkspaces{
		// 	Value: []admin.DomainWorkspace{
		// 		{
		// 			DisplayName: to.Ptr("Mark8ProjectTeam"),
		// 			ID: to.Ptr("e281785b-5608-41ac-a1a1-78b48b95b825"),
		// 		},
		// 		{
		// 			DisplayName: to.Ptr("Team southern region"),
		// 			ID: to.Ptr("24402490-9519-48b9-9d51-b2db4095a56b"),
		// 		},
		// 		{
		// 			DisplayName: to.Ptr("SalesAndMarketing"),
		// 			ID: to.Ptr("46f8ccd7-a209-4e12-978f-56ef3c44a68c"),
		// 	}},
		// }
	}
}

Output:

func (*DomainsClient) RoleAssignmentsBulkAssign 

func (client *DomainsClient) RoleAssignmentsBulkAssign(ctx context.Context, domainID string, domainRoleAssignmentRequest DomainRoleAssignmentRequest, options *DomainsClientRoleAssignmentsBulkAssignOptions) (DomainsClientRoleAssignmentsBulkAssignResponse, error)

RoleAssignmentsBulkAssign - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • domainRoleAssignmentRequest - The request payload for assigning domain members to the domain by principal.
  • options - DomainsClientRoleAssignmentsBulkAssignOptions contains the optional parameters for the DomainsClient.RoleAssignmentsBulkAssign method.
Example (AssignDomainAdminsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().RoleAssignmentsBulkAssign(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.DomainRoleAssignmentRequest{
		Type: to.Ptr(admin.DomainRoleAdmins),
		Principals: []admin.Principal{
			{
				Type: to.Ptr(admin.PrincipalTypeUser),
				ID:   to.Ptr("796ce6ad-9163-4c16-9559-c68192a251de"),
			}},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:
Example (AssignDomainContributorsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().RoleAssignmentsBulkAssign(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.DomainRoleAssignmentRequest{
		Type: to.Ptr(admin.DomainRoleContributors),
		Principals: []admin.Principal{
			{
				Type: to.Ptr(admin.PrincipalTypeUser),
				ID:   to.Ptr("796ce6ad-9163-4c16-9559-c68192a251de"),
			}},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) RoleAssignmentsBulkUnassign 

func (client *DomainsClient) RoleAssignmentsBulkUnassign(ctx context.Context, domainID string, domainRoleUnassignmentRequest DomainRoleUnassignmentRequest, options *DomainsClientRoleAssignmentsBulkUnassignOptions) (DomainsClientRoleAssignmentsBulkUnassignResponse, error)

RoleAssignmentsBulkUnassign - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • domainRoleUnassignmentRequest - The request payload for unassigning domain members from the domain by principal.
  • options - DomainsClientRoleAssignmentsBulkUnassignOptions contains the optional parameters for the DomainsClient.RoleAssignmentsBulkUnassign method.
Example (UnassignDomainAdminsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().RoleAssignmentsBulkUnassign(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.DomainRoleUnassignmentRequest{
		Type: to.Ptr(admin.DomainRoleAdmins),
		Principals: []admin.Principal{
			{
				Type: to.Ptr(admin.PrincipalTypeUser),
				ID:   to.Ptr("796ce6ad-9163-4c16-9559-c68192a251de"),
			}},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:
Example (UnassignDomainContributorsExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().RoleAssignmentsBulkUnassign(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.DomainRoleUnassignmentRequest{
		Type: to.Ptr(admin.DomainRoleContributors),
		Principals: []admin.Principal{
			{
				Type: to.Ptr(admin.PrincipalTypeUser),
				ID:   to.Ptr("796ce6ad-9163-4c16-9559-c68192a251de"),
			}},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) UnassignAllDomainWorkspaces 

func (client *DomainsClient) UnassignAllDomainWorkspaces(ctx context.Context, domainID string, options *DomainsClientUnassignAllDomainWorkspacesOptions) (DomainsClientUnassignAllDomainWorkspacesResponse, error)

UnassignAllDomainWorkspaces - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 10 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientUnassignAllDomainWorkspacesOptions contains the optional parameters for the DomainsClient.UnassignAllDomainWorkspaces method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().UnassignAllDomainWorkspaces(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) UnassignDomainWorkspacesByIDs 

func (client *DomainsClient) UnassignDomainWorkspacesByIDs(ctx context.Context, domainID string, options *DomainsClientUnassignDomainWorkspacesByIDsOptions) (DomainsClientUnassignDomainWorkspacesByIDsResponse, error)

UnassignDomainWorkspacesByIDs - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • options - DomainsClientUnassignDomainWorkspacesByIDsOptions contains the optional parameters for the DomainsClient.UnassignDomainWorkspacesByIDs method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDomainsClient().UnassignDomainWorkspacesByIDs(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", &admin.DomainsClientUnassignDomainWorkspacesByIDsOptions{UnassignDomainWorkspacesByIDsRequest: &admin.UnassignDomainWorkspacesByIDsRequest{
		WorkspacesIDs: []string{
			"e8de1852-7382-480a-8404-d5b1f5e1ab65",
			"5348d3a9-c096-4074-9083-09e3ca69c8e5",
			"ac561643-c5c5-4cf1-868e-8755a90e6fa3"},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DomainsClient) UpdateDomain 

func (client *DomainsClient) UpdateDomain(ctx context.Context, domainID string, updateDomainRequest UpdateDomainRequest, options *DomainsClientUpdateDomainOptions) (DomainsClientUpdateDomainResponse, error)

UpdateDomain - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum 25 requests per one minute per principal. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • domainID - The domain ID.
  • updateDomainRequest - The request payload for updating the domain.
  • options - DomainsClientUpdateDomainOptions contains the optional parameters for the DomainsClient.UpdateDomain method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDomainsClient().UpdateDomain(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.UpdateDomainRequest{
		Description:       to.Ptr("Domain's new description"),
		ContributorsScope: to.Ptr(admin.ContributorsScopeTypeSpecificUsersAndGroups),
		DisplayName:       to.Ptr("Domain's new name"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Domain = admin.Domain{
	// 	Description: to.Ptr("Domain's new description"),
	// 	ContributorsScope: to.Ptr(admin.ContributorsScopeTypeSpecificUsersAndGroups),
	// 	DisplayName: to.Ptr("Domain's new name"),
	// 	ID: to.Ptr("f2f6a374-789e-4d1d-9cc7-6e0b934fc529"),
	// }
}

Output:

type DomainsClientAssignDomainWorkspacesByCapacitiesResponse 

type DomainsClientAssignDomainWorkspacesByCapacitiesResponse struct {
}

DomainsClientAssignDomainWorkspacesByCapacitiesResponse contains the response from method DomainsClient.BeginAssignDomainWorkspacesByCapacities.

type DomainsClientAssignDomainWorkspacesByIDsOptions 

type DomainsClientAssignDomainWorkspacesByIDsOptions struct {
}

DomainsClientAssignDomainWorkspacesByIDsOptions contains the optional parameters for the DomainsClient.AssignDomainWorkspacesByIDs method.

type DomainsClientAssignDomainWorkspacesByIDsResponse 

type DomainsClientAssignDomainWorkspacesByIDsResponse struct {
}

DomainsClientAssignDomainWorkspacesByIDsResponse contains the response from method DomainsClient.AssignDomainWorkspacesByIDs.

type DomainsClientAssignDomainWorkspacesByPrincipalsResponse 

type DomainsClientAssignDomainWorkspacesByPrincipalsResponse struct {
}

DomainsClientAssignDomainWorkspacesByPrincipalsResponse contains the response from method DomainsClient.BeginAssignDomainWorkspacesByPrincipals.

type DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions 

type DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DomainsClientBeginAssignDomainWorkspacesByCapacitiesOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByCapacities method.

type DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions 

type DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

DomainsClientBeginAssignDomainWorkspacesByPrincipalsOptions contains the optional parameters for the DomainsClient.BeginAssignDomainWorkspacesByPrincipals method.

type DomainsClientCreateDomainOptions 

type DomainsClientCreateDomainOptions struct {
}

DomainsClientCreateDomainOptions contains the optional parameters for the DomainsClient.CreateDomain method.

type DomainsClientCreateDomainResponse 

type DomainsClientCreateDomainResponse struct {
	// Represents a domain or subdomain.
	Domain
}

DomainsClientCreateDomainResponse contains the response from method DomainsClient.CreateDomain.

type DomainsClientDeleteDomainOptions 

type DomainsClientDeleteDomainOptions struct {
}

DomainsClientDeleteDomainOptions contains the optional parameters for the DomainsClient.DeleteDomain method.

type DomainsClientDeleteDomainResponse 

type DomainsClientDeleteDomainResponse struct {
}

DomainsClientDeleteDomainResponse contains the response from method DomainsClient.DeleteDomain.

type DomainsClientGetDomainOptions 

type DomainsClientGetDomainOptions struct {
}

DomainsClientGetDomainOptions contains the optional parameters for the DomainsClient.GetDomain method.

type DomainsClientGetDomainResponse 

type DomainsClientGetDomainResponse struct {
	// Represents a domain or subdomain.
	Domain
}

DomainsClientGetDomainResponse contains the response from method DomainsClient.GetDomain.

type DomainsClientListDomainWorkspacesOptions 

type DomainsClientListDomainWorkspacesOptions struct {
	// A token for retrieving the next page of results.
	ContinuationToken *string
}

DomainsClientListDomainWorkspacesOptions contains the optional parameters for the DomainsClient.NewListDomainWorkspacesPager method.

type DomainsClientListDomainWorkspacesResponse 

type DomainsClientListDomainWorkspacesResponse struct {
	// A response wrapper for a list of all the workspaces assigned to a domain with a continuous token.
	DomainWorkspaces
}

DomainsClientListDomainWorkspacesResponse contains the response from method DomainsClient.NewListDomainWorkspacesPager.

type DomainsClientListDomainsOptions 

type DomainsClientListDomainsOptions struct {
	// When true, only return domains that have at least one workspace containing an item. Default: false.
	NonEmptyOnly *bool
}

DomainsClientListDomainsOptions contains the optional parameters for the DomainsClient.ListDomains method.

type DomainsClientListDomainsResponse 

type DomainsClientListDomainsResponse struct {
	// This is a response wrapper for a list of all domains.
	DomainsResponse
}

DomainsClientListDomainsResponse contains the response from method DomainsClient.ListDomains.

type DomainsClientRoleAssignmentsBulkAssignOptions 

type DomainsClientRoleAssignmentsBulkAssignOptions struct {
}

DomainsClientRoleAssignmentsBulkAssignOptions contains the optional parameters for the DomainsClient.RoleAssignmentsBulkAssign method.

type DomainsClientRoleAssignmentsBulkAssignResponse 

type DomainsClientRoleAssignmentsBulkAssignResponse struct {
}

DomainsClientRoleAssignmentsBulkAssignResponse contains the response from method DomainsClient.RoleAssignmentsBulkAssign.

type DomainsClientRoleAssignmentsBulkUnassignOptions 

type DomainsClientRoleAssignmentsBulkUnassignOptions struct {
}

DomainsClientRoleAssignmentsBulkUnassignOptions contains the optional parameters for the DomainsClient.RoleAssignmentsBulkUnassign method.

type DomainsClientRoleAssignmentsBulkUnassignResponse 

type DomainsClientRoleAssignmentsBulkUnassignResponse struct {
}

DomainsClientRoleAssignmentsBulkUnassignResponse contains the response from method DomainsClient.RoleAssignmentsBulkUnassign.

type DomainsClientUnassignAllDomainWorkspacesOptions 

type DomainsClientUnassignAllDomainWorkspacesOptions struct {
}

DomainsClientUnassignAllDomainWorkspacesOptions contains the optional parameters for the DomainsClient.UnassignAllDomainWorkspaces method.

type DomainsClientUnassignAllDomainWorkspacesResponse 

type DomainsClientUnassignAllDomainWorkspacesResponse struct {
}

DomainsClientUnassignAllDomainWorkspacesResponse contains the response from method DomainsClient.UnassignAllDomainWorkspaces.

type DomainsClientUnassignDomainWorkspacesByIDsOptions 

type DomainsClientUnassignDomainWorkspacesByIDsOptions struct {
	// The request payload for unassigning workspaces from the domain by workspace ID.
	UnassignDomainWorkspacesByIDsRequest *UnassignDomainWorkspacesByIDsRequest
}

DomainsClientUnassignDomainWorkspacesByIDsOptions contains the optional parameters for the DomainsClient.UnassignDomainWorkspacesByIDs method.

type DomainsClientUnassignDomainWorkspacesByIDsResponse 

type DomainsClientUnassignDomainWorkspacesByIDsResponse struct {
}

DomainsClientUnassignDomainWorkspacesByIDsResponse contains the response from method DomainsClient.UnassignDomainWorkspacesByIDs.

type DomainsClientUpdateDomainOptions 

type DomainsClientUpdateDomainOptions struct {
}

DomainsClientUpdateDomainOptions contains the optional parameters for the DomainsClient.UpdateDomain method.

type DomainsClientUpdateDomainResponse 

type DomainsClientUpdateDomainResponse struct {
	// Represents a domain or subdomain.
	Domain
}

DomainsClientUpdateDomainResponse contains the response from method DomainsClient.UpdateDomain.

type DomainsResponse 

type DomainsResponse struct {
	// The list of domains.
	Domains []Domain
}

DomainsResponse - This is a response wrapper for a list of all domains.

func (DomainsResponse) MarshalJSON 

func (d DomainsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DomainsResponse.

func (*DomainsResponse) UnmarshalJSON 

func (d *DomainsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DomainsResponse.

type ExternalDataShare 

type ExternalDataShare struct {
	// READ-ONLY; The principal that created the external data share.
	CreatorPrincipal *Principal

	// READ-ONLY; The external data share ID.
	ID *string

	// READ-ONLY; The item ID.
	ItemID *string

	// READ-ONLY; The path or list of paths that are externally shared.
	Paths []string

	// READ-ONLY; The recipient who was invited to accept the external data share.
	Recipient *ExternalDataShareRecipient

	// READ-ONLY; The status of the external data share.
	Status *ExternalDataShareStatus

	// READ-ONLY; The workspace ID.
	WorkspaceID *string

	// READ-ONLY; The tenant ID in which the external data share was accepted.
	AcceptedByTenantID *string

	// READ-ONLY; The expiration date and time (UTC) of the invitation to the external data share.
	ExpirationTimeUTC *time.Time

	// READ-ONLY; The URL for accepting the invitation to the external data share.
	InvitationURL *string
}

ExternalDataShare - An external data share object.

func (ExternalDataShare) MarshalJSON 

func (e ExternalDataShare) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalDataShare.

func (*ExternalDataShare) UnmarshalJSON 

func (e *ExternalDataShare) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalDataShare.

type ExternalDataShareRecipient 

type ExternalDataShareRecipient struct {
	// REQUIRED; The recipient's email address.
	UserPrincipalName *string

	// The recipient's tenant ID.
	TenantID *string
}

ExternalDataShareRecipient - A representation of the the external data share recipient.

func (ExternalDataShareRecipient) MarshalJSON 

func (e ExternalDataShareRecipient) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalDataShareRecipient.

func (*ExternalDataShareRecipient) UnmarshalJSON 

func (e *ExternalDataShareRecipient) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalDataShareRecipient.

type ExternalDataShareStatus 

type ExternalDataShareStatus string

ExternalDataShareStatus - The status of a given external data share. Additional ExternalDataShareStatus types may be added over time. 

const (
	// ExternalDataShareStatusActive - The invitation has been accepted by the recipient and the external data share is active.
	ExternalDataShareStatusActive ExternalDataShareStatus = "Active"
	// ExternalDataShareStatusInvitationExpired - The invitation expired and can no longer be accepted by the recipient.
	ExternalDataShareStatusInvitationExpired ExternalDataShareStatus = "InvitationExpired"
	// ExternalDataShareStatusPending - An invitation was created and is now pending acceptance by the recipient.
	ExternalDataShareStatusPending ExternalDataShareStatus = "Pending"
	// ExternalDataShareStatusRevoked - The external data share was revoked.
	ExternalDataShareStatusRevoked ExternalDataShareStatus = "Revoked"
)

func PossibleExternalDataShareStatusValues 

func PossibleExternalDataShareStatusValues() []ExternalDataShareStatus

PossibleExternalDataShareStatusValues returns the possible values for the ExternalDataShareStatus const type.

type ExternalDataShares 

type ExternalDataShares struct {
	// READ-ONLY; A list of external data shares.
	Value []ExternalDataShare

	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string
}

ExternalDataShares - A list of external data shares with a continuation token.

func (ExternalDataShares) MarshalJSON 

func (e ExternalDataShares) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExternalDataShares.

func (*ExternalDataShares) UnmarshalJSON 

func (e *ExternalDataShares) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExternalDataShares.

type ExternalDataSharesClient 

type ExternalDataSharesClient struct {
	// contains filtered or unexported fields
}

ExternalDataSharesClient contains the methods for the ExternalDataShares group. Don't use this type directly, use a constructor function instead.

func (*ExternalDataSharesClient) ListExternalDataShares 

func (client *ExternalDataSharesClient) ListExternalDataShares(ctx context.Context, options *ExternalDataSharesClientListExternalDataSharesOptions) ([]ExternalDataShare, error)

ListExternalDataShares - returns array of ExternalDataShare from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records.

PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All

REQUIRED TENANT SETTINGS To use this API, enable the 'External data sharing' admin switch for the calling principal.

LIMITATIONS Maximum 10 requests per minute.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • options - ExternalDataSharesClientListExternalDataSharesOptions contains the optional parameters for the ExternalDataSharesClient.NewListExternalDataSharesPager method.

func (*ExternalDataSharesClient) NewListExternalDataSharesPager 

func (client *ExternalDataSharesClient) NewListExternalDataSharesPager(options *ExternalDataSharesClientListExternalDataSharesOptions) *runtime.Pager[ExternalDataSharesClientListExternalDataSharesResponse]

NewListExternalDataSharesPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records. PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All REQUIRED TENANT SETTINGS To use this API, enable the 'External data sharing' admin switch for the calling principal. LIMITATIONS Maximum 10 requests per minute. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • options - ExternalDataSharesClientListExternalDataSharesOptions contains the optional parameters for the ExternalDataSharesClient.NewListExternalDataSharesPager method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewExternalDataSharesClient().NewListExternalDataSharesPager(&admin.ExternalDataSharesClientListExternalDataSharesOptions{ContinuationToken: nil})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ExternalDataShares = admin.ExternalDataShares{
		// 	Value: []admin.ExternalDataShare{
		// 		{
		// 			CreatorPrincipal: &admin.Principal{
		// 				Type: to.Ptr(admin.PrincipalTypeUser),
		// 				DisplayName: to.Ptr("Jacob Hancock"),
		// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 				UserDetails: &admin.PrincipalUserDetails{
		// 					UserPrincipalName: to.Ptr("jacob@contoso.com"),
		// 				},
		// 			},
		// 			ExpirationTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-13T00:00:00.000Z"); return t}()),
		// 			ID: to.Ptr("dccc162f-7a41-4720-83c3-5c7e81187959"),
		// 			InvitationURL: to.Ptr("https://app.fabric.microsoft.com/externaldatasharing/accept?si=VyT5NJ3%2bNkySqEmf368Pjw-dccc162f-7a41-4720-83c3-5c7e81187959"),
		// 			ItemID: to.Ptr("5b218778-e7a5-4d73-8187-f10824047715"),
		// 			Paths: []string{
		// 				"Files/Sales/Contoso_Sales_2023"},
		// 				Recipient: &admin.ExternalDataShareRecipient{
		// 					UserPrincipalName: to.Ptr("lisa@fabrikam.com"),
		// 				},
		// 				Status: to.Ptr(admin.ExternalDataShareStatusPending),
		// 				WorkspaceID: to.Ptr("cfafbeb1-8037-4d0c-896e-a46fb27ff229"),
		// 			},
		// 			{
		// 				AcceptedByTenantID: to.Ptr("c51dc03f-268a-4da0-a879-25f24947ab8b"),
		// 				CreatorPrincipal: &admin.Principal{
		// 					Type: to.Ptr(admin.PrincipalTypeUser),
		// 					DisplayName: to.Ptr("Jacob Hancock"),
		// 					ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 					UserDetails: &admin.PrincipalUserDetails{
		// 						UserPrincipalName: to.Ptr("jacob@contoso.com"),
		// 					},
		// 				},
		// 				ExpirationTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-31T00:00:00.000Z"); return t}()),
		// 				ID: to.Ptr("96c21561-65b8-4b23-bb9a-ee8cef945c45"),
		// 				InvitationURL: to.Ptr("https://app.fabric.microsoft.com/externaldatasharing/accept?si=VyT5NJ3%2bNkySqEmf368Pjw-96c21561-65b8-4b23-bb9a-ee8cef945c45"),
		// 				ItemID: to.Ptr("5b218778-e7a5-4d73-8187-f10824047715"),
		// 				Paths: []string{
		// 					"Files/Sales/Contoso_Sales_2023"},
		// 					Recipient: &admin.ExternalDataShareRecipient{
		// 						UserPrincipalName: to.Ptr("lisa@fabrikam.com"),
		// 					},
		// 					Status: to.Ptr(admin.ExternalDataShareStatusActive),
		// 					WorkspaceID: to.Ptr("cfafbeb1-8037-4d0c-896e-a46fb27ff229"),
		// 				},
		// 				{
		// 					CreatorPrincipal: &admin.Principal{
		// 						Type: to.Ptr(admin.PrincipalTypeUser),
		// 						DisplayName: to.Ptr("Eric Solomon"),
		// 						ID: to.Ptr("81fac5e1-2a81-421b-a168-110b1c72fa11"),
		// 						UserDetails: &admin.PrincipalUserDetails{
		// 							UserPrincipalName: to.Ptr("eric@contoso.com"),
		// 						},
		// 					},
		// 					ExpirationTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-01T00:00:00.000Z"); return t}()),
		// 					ID: to.Ptr("0f40aeca-8f78-4a6f-a552-e5c45faadc60"),
		// 					InvitationURL: to.Ptr("https://app.fabric.microsoft.com/externaldatasharing/accept?si=VyT5NJ3%2bNkySqEmf368Pjw-0f40aeca-8f78-4a6f-a552-e5c45faadc60"),
		// 					ItemID: to.Ptr("5b218778-e7a5-4d73-8187-f10824047715"),
		// 					Paths: []string{
		// 						"Files/Sales/Contoso_Sales_2023"},
		// 						Recipient: &admin.ExternalDataShareRecipient{
		// 							UserPrincipalName: to.Ptr("lisa@fabrikam.com"),
		// 						},
		// 						Status: to.Ptr(admin.ExternalDataShareStatusInvitationExpired),
		// 						WorkspaceID: to.Ptr("cfafbeb1-8037-4d0c-896e-a46fb27ff229"),
		// 					},
		// 					{
		// 						AcceptedByTenantID: to.Ptr("c51dc03f-268a-4da0-a879-25f24947ab8b"),
		// 						CreatorPrincipal: &admin.Principal{
		// 							Type: to.Ptr(admin.PrincipalTypeUser),
		// 							DisplayName: to.Ptr("Eric Solomon"),
		// 							ID: to.Ptr("81fac5e1-2a81-421b-a168-110b1c72fa11"),
		// 							UserDetails: &admin.PrincipalUserDetails{
		// 								UserPrincipalName: to.Ptr("eric@contoso.com"),
		// 							},
		// 						},
		// 						ExpirationTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-01T00:00:00.000Z"); return t}()),
		// 						ID: to.Ptr("89e82a82-0140-4837-8eee-9c919e3e5952"),
		// 						InvitationURL: to.Ptr("https://app.fabric.microsoft.com/externaldatasharing/accept?si=VyT5NJ3%2bNkySqEmf368Pjw-89e82a82-0140-4837-8eee-9c919e3e5952"),
		// 						ItemID: to.Ptr("5b218778-e7a5-4d73-8187-f10824047715"),
		// 						Paths: []string{
		// 							"Files/Sales/Contoso_Sales_2023"},
		// 							Recipient: &admin.ExternalDataShareRecipient{
		// 								UserPrincipalName: to.Ptr("lisa@fabrikam.com"),
		// 							},
		// 							Status: to.Ptr(admin.ExternalDataShareStatusRevoked),
		// 							WorkspaceID: to.Ptr("cfafbeb1-8037-4d0c-896e-a46fb27ff229"),
		// 					}},
		// 				}
	}
}

Output:

func (*ExternalDataSharesClient) RevokeExternalDataShare 

func (client *ExternalDataSharesClient) RevokeExternalDataShare(ctx context.Context, workspaceID string, itemID string, externalDataShareID string, options *ExternalDataSharesClientRevokeExternalDataShareOptions) (ExternalDataSharesClientRevokeExternalDataShareResponse, error)

RevokeExternalDataShare - PERMISSIONS The caller must be a Fabric administrator. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All REQUIRED TENANT SETTINGS To use this API, enable the 'External data sharing' admin switch for the calling principal. LIMITATIONS Maximum 10 requests per minute. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • itemID - The item ID.
  • externalDataShareID - The external data share ID.
  • options - ExternalDataSharesClientRevokeExternalDataShareOptions contains the optional parameters for the ExternalDataSharesClient.RevokeExternalDataShare method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewExternalDataSharesClient().RevokeExternalDataShare(ctx, "cfafbeb1-8037-4d0c-896e-a46fb27ff229", "5b218778-e7a5-4d73-8187-f10824047715", "dccc162f-7a41-4720-83c3-5c7e81187959", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

type ExternalDataSharesClientListExternalDataSharesOptions 

type ExternalDataSharesClientListExternalDataSharesOptions struct {
	// A token for retrieving the next page of results.
	ContinuationToken *string
}

ExternalDataSharesClientListExternalDataSharesOptions contains the optional parameters for the ExternalDataSharesClient.NewListExternalDataSharesPager method.

type ExternalDataSharesClientListExternalDataSharesResponse 

type ExternalDataSharesClientListExternalDataSharesResponse struct {
	// A list of external data shares with a continuation token.
	ExternalDataShares
}

ExternalDataSharesClientListExternalDataSharesResponse contains the response from method ExternalDataSharesClient.NewListExternalDataSharesPager.

type ExternalDataSharesClientRevokeExternalDataShareOptions 

type ExternalDataSharesClientRevokeExternalDataShareOptions struct {
}

ExternalDataSharesClientRevokeExternalDataShareOptions contains the optional parameters for the ExternalDataSharesClient.RevokeExternalDataShare method.

type ExternalDataSharesClientRevokeExternalDataShareResponse 

type ExternalDataSharesClientRevokeExternalDataShareResponse struct {
}

ExternalDataSharesClientRevokeExternalDataShareResponse contains the response from method ExternalDataSharesClient.RevokeExternalDataShare.

type GitConnectionDetails 

type GitConnectionDetails struct {
	// REQUIRED; The provider details.
	GitProviderDetails GitProviderDetailsClassification

	// REQUIRED; The workspace ID.
	WorkspaceID *string
}

GitConnectionDetails - Represents the details of a Git connection for a workspace.

func (GitConnectionDetails) MarshalJSON 

func (g GitConnectionDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GitConnectionDetails.

func (*GitConnectionDetails) UnmarshalJSON 

func (g *GitConnectionDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GitConnectionDetails.

type GitConnections 

type GitConnections struct {
	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string

	// The list of Git connections for a given tenant.
	Value []GitConnectionDetails
}

GitConnections - A response wrapper for a list of all the Git connections for a given tenant with a continuous token.

func (GitConnections) MarshalJSON 

func (g GitConnections) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GitConnections.

func (*GitConnections) UnmarshalJSON 

func (g *GitConnections) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GitConnections.

type GitHubDetails 

type GitHubDetails struct {
	// REQUIRED; The branch name. Maximum length is 250 characters.
	BranchName *string

	// REQUIRED; The relative path to the directory. Maximum length is 256 characters.
	DirectoryName *string

	// REQUIRED; A Git provider type. Additional provider types may be added over time.
	GitProviderType *GitProviderType

	// REQUIRED; The owner name. Maximum length is 100 characters.
	OwnerName *string

	// REQUIRED; The repository name. Maximum length is 128 characters.
	RepositoryName *string
}

GitHubDetails - GitHub provider details.

func (*GitHubDetails) GetGitProviderDetails 

func (g *GitHubDetails) GetGitProviderDetails() *GitProviderDetails

GetGitProviderDetails implements the GitProviderDetailsClassification interface for type GitHubDetails.

func (GitHubDetails) MarshalJSON 

func (g GitHubDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GitHubDetails.

func (*GitHubDetails) UnmarshalJSON 

func (g *GitHubDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GitHubDetails.

type GitProviderDetails 

type GitProviderDetails struct {
	// REQUIRED; The branch name. Maximum length is 250 characters.
	BranchName *string

	// REQUIRED; The relative path to the directory. Maximum length is 256 characters.
	DirectoryName *string

	// REQUIRED; A Git provider type. Additional provider types may be added over time.
	GitProviderType *GitProviderType

	// REQUIRED; The repository name. Maximum length is 128 characters.
	RepositoryName *string
}

GitProviderDetails - The Git provider details.

func (*GitProviderDetails) GetGitProviderDetails 

func (g *GitProviderDetails) GetGitProviderDetails() *GitProviderDetails

GetGitProviderDetails implements the GitProviderDetailsClassification interface for type GitProviderDetails.

func (GitProviderDetails) MarshalJSON 

func (g GitProviderDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GitProviderDetails.

func (*GitProviderDetails) UnmarshalJSON 

func (g *GitProviderDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GitProviderDetails.

type GitProviderDetailsClassification 

type GitProviderDetailsClassification interface {
	// GetGitProviderDetails returns the GitProviderDetails content of the underlying type.
	GetGitProviderDetails() *GitProviderDetails
}

GitProviderDetailsClassification provides polymorphic access to related types. Call the interface's GetGitProviderDetails() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AzureDevOpsDetails, *GitHubDetails, *GitProviderDetails

type GitProviderType 

type GitProviderType string

GitProviderType - A Git provider type. Additional provider types may be added over time. 

const (
	// GitProviderTypeAzureDevOps - Azure DevOps provider
	GitProviderTypeAzureDevOps GitProviderType = "AzureDevOps"
	// GitProviderTypeGitHub - GitHub provider
	GitProviderTypeGitHub GitProviderType = "GitHub"
)

func PossibleGitProviderTypeValues 

func PossibleGitProviderTypeValues() []GitProviderType

PossibleGitProviderTypeValues returns the possible values for the GitProviderType const type.

type GroupType 

type GroupType string

GroupType - The type of the group. Additional group types may be added over time. 

const (
	// GroupTypeDistributionList - Principal is a distribution list.
	GroupTypeDistributionList GroupType = "DistributionList"
	// GroupTypeSecurityGroup - Principal is a security group.
	GroupTypeSecurityGroup GroupType = "SecurityGroup"
	// GroupTypeUnknown - Principal group type is unknown.
	GroupTypeUnknown GroupType = "Unknown"
)

func PossibleGroupTypeValues 

func PossibleGroupTypeValues() []GroupType

PossibleGroupTypeValues returns the possible values for the GroupType const type.

type Item 

type Item struct {
	// READ-ONLY; The item ID.
	ID *string

	// Item details including item type and item usage.
	Description *string

	// The last updated date and time.
	LastUpdatedDate *time.Time

	// The item name.
	Name *string

	// READ-ONLY; The capacity ID of the workspace.
	CapacityID *string

	// READ-ONLY; The item's owner.
	CreatorPrincipal *Principal

	// READ-ONLY; The item status.
	State *ItemState

	// READ-ONLY; The item type. Includes values such as Synapse, Notebook, Kqldatabase and SynapseWorkbook.
	Type *ItemType

	// READ-ONLY; The workspace ID of item.
	WorkspaceID *string
}

Item details.

func (Item) MarshalJSON 

func (i Item) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Item.

func (*Item) UnmarshalJSON 

func (i *Item) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Item.

type ItemAccessDetail 

type ItemAccessDetail struct {
	// Workload permissions such as readAll and viewOutput.
	AdditionalPermissions []string

	// Item permissions such as read and reshare.
	Permissions []ItemPermissions

	// Entity type.
	Type *ItemType
}

ItemAccessDetail - Item permission details such as read and reshare.

func (ItemAccessDetail) MarshalJSON 

func (i ItemAccessDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemAccessDetail.

func (*ItemAccessDetail) UnmarshalJSON 

func (i *ItemAccessDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemAccessDetail.

type ItemAccessDetails 

type ItemAccessDetails struct {
	// READ-ONLY; Item permissions for the user.
	ItemAccessDetails *ItemAccessDetail

	// READ-ONLY; Information regarding the user who has access to the entity.
	Principal *Principal
}

ItemAccessDetails - User access details for an item.

func (ItemAccessDetails) MarshalJSON 

func (i ItemAccessDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemAccessDetails.

func (*ItemAccessDetails) UnmarshalJSON 

func (i *ItemAccessDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemAccessDetails.

type ItemAccessDetailsResponse 

type ItemAccessDetailsResponse struct {
	// A list of users with access to an entity.
	AccessDetails []ItemAccessDetails
}

ItemAccessDetailsResponse - A list of users with access to a given entity.

func (ItemAccessDetailsResponse) MarshalJSON 

func (i ItemAccessDetailsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemAccessDetailsResponse.

func (*ItemAccessDetailsResponse) UnmarshalJSON 

func (i *ItemAccessDetailsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemAccessDetailsResponse.

type ItemChangeLabelStatus 

type ItemChangeLabelStatus struct {
	// READ-ONLY; The unique ID of a Fabric item. The ID is in UUID format.
	ID *string

	// READ-ONLY; The status of an information protection label change operation. Additional tenant setting property types may
	// be added over time.
	Status *Status

	// READ-ONLY; The Fabric item type.
	Type *ItemType
}

ItemChangeLabelStatus - The unique ID and information protection label change status of a Fabric item

func (ItemChangeLabelStatus) MarshalJSON 

func (i ItemChangeLabelStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemChangeLabelStatus.

func (*ItemChangeLabelStatus) UnmarshalJSON 

func (i *ItemChangeLabelStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemChangeLabelStatus.

type ItemInfo 

type ItemInfo struct {
	// REQUIRED; An ID in UUID format.
	ID *string

	// REQUIRED; The item type.
	Type *ItemType
}

ItemInfo - The item information, including item ID and type.

func (ItemInfo) MarshalJSON 

func (i ItemInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemInfo.

func (*ItemInfo) UnmarshalJSON 

func (i *ItemInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemInfo.

type ItemPermissions 

type ItemPermissions string

ItemPermissions - Item permissions. Additional item permissions may be added over time. 

const (
	// ItemPermissionsExecute - User can execute and cancel item jobs.
	ItemPermissionsExecute ItemPermissions = "Execute"
	// ItemPermissionsExplore - User can build items on other items.
	ItemPermissionsExplore ItemPermissions = "Explore"
	// ItemPermissionsRead - User can read the metadata about an item.
	ItemPermissionsRead ItemPermissions = "Read"
	// ItemPermissionsReshare - User can share an item with other users.
	ItemPermissionsReshare ItemPermissions = "Reshare"
	// ItemPermissionsWrite - User can perform write operations on an item.
	ItemPermissionsWrite ItemPermissions = "Write"
)

func PossibleItemPermissionsValues 

func PossibleItemPermissionsValues() []ItemPermissions

PossibleItemPermissionsValues returns the possible values for the ItemPermissions const type.

type ItemState 

type ItemState string

ItemState - The item state. Additional item states may be added over time. 

const (
	// ItemStateActive - An active item.
	ItemStateActive ItemState = "Active"
)

func PossibleItemStateValues 

func PossibleItemStateValues() []ItemState

PossibleItemStateValues returns the possible values for the ItemState const type.

type ItemType 

type ItemType string

ItemType - The type of the item. Additional item types may be added over time. 

const (
	// ItemTypeDashboard - PowerBI dashboard.
	ItemTypeDashboard ItemType = "Dashboard"
	// ItemTypeDataPipeline - A data pipeline.
	ItemTypeDataPipeline ItemType = "DataPipeline"
	// ItemTypeDatamart - PowerBI datamart.
	ItemTypeDatamart ItemType = "Datamart"
	// ItemTypeEnvironment - An environment.
	ItemTypeEnvironment ItemType = "Environment"
	// ItemTypeEventhouse - An eventhouse.
	ItemTypeEventhouse ItemType = "Eventhouse"
	// ItemTypeEventstream - An eventstream.
	ItemTypeEventstream ItemType = "Eventstream"
	// ItemTypeGraphQLAPI - An API for GraphQL item.
	ItemTypeGraphQLAPI ItemType = "GraphQLApi"
	// ItemTypeKQLDashboard - A KQL dashboard.
	ItemTypeKQLDashboard ItemType = "KQLDashboard"
	// ItemTypeKQLDatabase - A KQL database.
	ItemTypeKQLDatabase ItemType = "KQLDatabase"
	// ItemTypeKQLQueryset - A KQL queryset.
	ItemTypeKQLQueryset ItemType = "KQLQueryset"
	// ItemTypeLakehouse - A lakehouse.
	ItemTypeLakehouse ItemType = "Lakehouse"
	// ItemTypeMLExperiment - A machine learning experiment.
	ItemTypeMLExperiment ItemType = "MLExperiment"
	// ItemTypeMLModel - A machine learning model.
	ItemTypeMLModel ItemType = "MLModel"
	// ItemTypeMirroredDatabase - A mirrored database.
	ItemTypeMirroredDatabase ItemType = "MirroredDatabase"
	// ItemTypeMirroredWarehouse - A mirrored warehouse.
	ItemTypeMirroredWarehouse ItemType = "MirroredWarehouse"
	// ItemTypeNotebook - A notebook.
	ItemTypeNotebook ItemType = "Notebook"
	// ItemTypePaginatedReport - PowerBI paginated report.
	ItemTypePaginatedReport ItemType = "PaginatedReport"
	// ItemTypeReflex - A Reflex.
	ItemTypeReflex ItemType = "Reflex"
	// ItemTypeReport - PowerBI report.
	ItemTypeReport ItemType = "Report"
	// ItemTypeSQLEndpoint - An SQL endpoint.
	ItemTypeSQLEndpoint ItemType = "SQLEndpoint"
	// ItemTypeSemanticModel - PowerBI semantic model.
	ItemTypeSemanticModel ItemType = "SemanticModel"
	// ItemTypeSparkJobDefinition - A spark job definition.
	ItemTypeSparkJobDefinition ItemType = "SparkJobDefinition"
	// ItemTypeWarehouse - A warehouse.
	ItemTypeWarehouse ItemType = "Warehouse"
)

func PossibleItemTypeValues 

func PossibleItemTypeValues() []ItemType

PossibleItemTypeValues returns the possible values for the ItemType const type.

type Items 

type Items struct {
	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string

	// The list of items for a given tenant.
	ItemEntities []Item
}

Items - A list of items.

func (Items) MarshalJSON 

func (i Items) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Items.

func (*Items) UnmarshalJSON 

func (i *Items) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Items.

type ItemsChangeLabelResponse 

type ItemsChangeLabelResponse struct {
	// A list of items change label status.
	ItemsChangeLabelStatus []ItemChangeLabelStatus
}

ItemsChangeLabelResponse - A list of the unique IDs and information protection label change status of the Fabric items in the label change request.

func (ItemsChangeLabelResponse) MarshalJSON 

func (i ItemsChangeLabelResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ItemsChangeLabelResponse.

func (*ItemsChangeLabelResponse) UnmarshalJSON 

func (i *ItemsChangeLabelResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ItemsChangeLabelResponse.

type ItemsClient 

type ItemsClient struct {
	// contains filtered or unexported fields
}

ItemsClient contains the methods for the Items group. Don't use this type directly, use a constructor function instead.

func (*ItemsClient) GetItem 

func (client *ItemsClient) GetItem(ctx context.Context, workspaceID string, itemID string, options *ItemsClientGetItemOptions) (ItemsClientGetItemResponse, error)

GetItem - PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • itemID - The item ID
  • options - ItemsClientGetItemOptions contains the optional parameters for the ItemsClient.GetItem method.
Example (GetItemDetailsByIdAndTypeExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewItemsClient().GetItem(ctx, "7f4496db-9929-47bd-89c0-d7eb2f517a98", "f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.ItemsClientGetItemOptions{Type: to.Ptr("Report")})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Item = admin.Item{
	// 	Name: to.Ptr("Test"),
	// 	Type: to.Ptr(admin.ItemTypeReport),
	// 	Description: to.Ptr("Test Jacob's Report,"),
	// 	CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F771A506851"),
	// 	CreatorPrincipal: &admin.Principal{
	// 		Type: to.Ptr(admin.PrincipalTypeUser),
	// 		DisplayName: to.Ptr("Jacob Hancock"),
	// 		ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
	// 		UserDetails: &admin.PrincipalUserDetails{
	// 			UserPrincipalName: to.Ptr("Jacob@example.com"),
	// 		},
	// 	},
	// 	ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
	// 	LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-29T17:47:29.986Z"); return t}()),
	// 	State: to.Ptr(admin.ItemStateActive),
	// 	WorkspaceID: to.Ptr("7f4496db-9929-47bd-89c0-d7eb2f517a98"),
	// }
}

Output:
Example (GetItemDetailsByIdExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewItemsClient().GetItem(ctx, "7f4496db-9929-47bd-89c0-d7eb2f517a98", "f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.ItemsClientGetItemOptions{Type: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Item = admin.Item{
	// 	Name: to.Ptr("Test"),
	// 	Type: to.Ptr(admin.ItemType("Kusto")),
	// 	Description: to.Ptr("Test Jacob's notebook."),
	// 	CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F771A506851"),
	// 	CreatorPrincipal: &admin.Principal{
	// 		Type: to.Ptr(admin.PrincipalTypeUser),
	// 		DisplayName: to.Ptr("Jacob Hancock"),
	// 		ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
	// 		UserDetails: &admin.PrincipalUserDetails{
	// 			UserPrincipalName: to.Ptr("Jacob@example.com"),
	// 		},
	// 	},
	// 	ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
	// 	LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-29T17:47:29.986Z"); return t}()),
	// 	State: to.Ptr(admin.ItemStateActive),
	// 	WorkspaceID: to.Ptr("7f4496db-9929-47bd-89c0-d7eb2f517a98"),
	// }
}

Output:

func (*ItemsClient) ListItemAccessDetails 

func (client *ItemsClient) ListItemAccessDetails(ctx context.Context, workspaceID string, itemID string, options *ItemsClientListItemAccessDetailsOptions) (ItemsClientListItemAccessDetailsResponse, error)

ListItemAccessDetails - PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • itemID - The item ID.
  • options - ItemsClientListItemAccessDetailsOptions contains the optional parameters for the ItemsClient.ListItemAccessDetails method.
Example (ListOfUsersForGivenItemIdAndTypeExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewItemsClient().ListItemAccessDetails(ctx, "7f4496db-9929-47bd-89c0-d7eb2f517a98", "f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.ItemsClientListItemAccessDetailsOptions{Type: to.Ptr("Report")})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ItemAccessDetailsResponse = admin.ItemAccessDetailsResponse{
	// 	AccessDetails: []admin.ItemAccessDetails{
	// 		{
	// 			ItemAccessDetails: &admin.ItemAccessDetail{
	// 				Type: to.Ptr(admin.ItemTypeReport),
	// 				AdditionalPermissions: []string{
	// 					"ReadAll"},
	// 					Permissions: []admin.ItemPermissions{
	// 						admin.ItemPermissionsRead,
	// 						admin.ItemPermissionsReshare},
	// 					},
	// 					Principal: &admin.Principal{
	// 						Type: to.Ptr(admin.PrincipalTypeUser),
	// 						DisplayName: to.Ptr("Jacob Hancock"),
	// 						ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
	// 						UserDetails: &admin.PrincipalUserDetails{
	// 							UserPrincipalName: to.Ptr("jacob@example.com"),
	// 						},
	// 					},
	// 			}},
	// 		}
}

Output:
Example (ListOfUsersForGivenItemIdExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewItemsClient().ListItemAccessDetails(ctx, "7f4496db-9929-47bd-89c0-d7eb2f517a98", "f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.ItemsClientListItemAccessDetailsOptions{Type: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ItemAccessDetailsResponse = admin.ItemAccessDetailsResponse{
	// 	AccessDetails: []admin.ItemAccessDetails{
	// 		{
	// 			ItemAccessDetails: &admin.ItemAccessDetail{
	// 				Type: to.Ptr(admin.ItemTypeNotebook),
	// 				AdditionalPermissions: []string{
	// 					"ReadAll",
	// 					"viewOutput"},
	// 					Permissions: []admin.ItemPermissions{
	// 						admin.ItemPermissionsRead,
	// 						admin.ItemPermissionsReshare},
	// 					},
	// 					Principal: &admin.Principal{
	// 						Type: to.Ptr(admin.PrincipalTypeUser),
	// 						DisplayName: to.Ptr("Jacob Hancock"),
	// 						ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
	// 						UserDetails: &admin.PrincipalUserDetails{
	// 							UserPrincipalName: to.Ptr("jacob@example.com"),
	// 						},
	// 					},
	// 				},
	// 				{
	// 					ItemAccessDetails: &admin.ItemAccessDetail{
	// 						Type: to.Ptr(admin.ItemTypeNotebook),
	// 						AdditionalPermissions: []string{
	// 							"ReadAll"},
	// 							Permissions: []admin.ItemPermissions{
	// 								admin.ItemPermissionsRead,
	// 								admin.ItemPermissionsReshare,
	// 								admin.ItemPermissionsExplore},
	// 							},
	// 							Principal: &admin.Principal{
	// 								Type: to.Ptr(admin.PrincipalTypeUser),
	// 								DisplayName: to.Ptr("Eric Solomon"),
	// 								ID: to.Ptr("c7db8e03-c8cb-4d4c-9f64-1dcd327c9d3c"),
	// 								UserDetails: &admin.PrincipalUserDetails{
	// 									UserPrincipalName: to.Ptr("eric@example.com"),
	// 								},
	// 							},
	// 						},
	// 						{
	// 							ItemAccessDetails: &admin.ItemAccessDetail{
	// 								Type: to.Ptr(admin.ItemTypeNotebook),
	// 								AdditionalPermissions: []string{
	// 								},
	// 								Permissions: []admin.ItemPermissions{
	// 									admin.ItemPermissionsRead,
	// 									admin.ItemPermissionsReshare},
	// 								},
	// 								Principal: &admin.Principal{
	// 									Type: to.Ptr(admin.PrincipalTypeGroup),
	// 									DisplayName: to.Ptr("TestSecurityGroup"),
	// 									GroupDetails: &admin.PrincipalGroupDetails{
	// 										GroupType: to.Ptr(admin.GroupTypeSecurityGroup),
	// 									},
	// 									ID: to.Ptr("f51b705f-a409-4d40-9197-c5d5f349e2f0"),
	// 								},
	// 						}},
	// 					}
}

Output:

func (*ItemsClient) ListItems 

func (client *ItemsClient) ListItems(ctx context.Context, options *ItemsClientListItemsOptions) ([]Item, error)

ListItems - returns array of Item from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records.

Page order:

  1. Fabric items
  2. Datamarts
  3. Reports
  4. Dashboards
  5. SemanticModels
  6. Apps
  7. Dataflows

PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All

LIMITATIONS Maximum 200 requests per hour.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • options - ItemsClientListItemsOptions contains the optional parameters for the ItemsClient.NewListItemsPager method.

func (*ItemsClient) NewListItemsPager 

func (client *ItemsClient) NewListItemsPager(options *ItemsClientListItemsOptions) *runtime.Pager[ItemsClientListItemsResponse]

NewListItemsPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records. Page order: 1. Fabric items 2. Datamarts 3. Reports 4. Dashboards 5. SemanticModels 6. Apps 7. Dataflows PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • options - ItemsClientListItemsOptions contains the optional parameters for the ItemsClient.NewListItemsPager method.
Example (GetAListOfItemsUsingTypeQueryParameterExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewItemsClient().NewListItemsPager(&admin.ItemsClientListItemsOptions{WorkspaceID: nil,
		CapacityID:        nil,
		State:             nil,
		Type:              to.Ptr("Report"),
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.ItemEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.Items = admin.Items{
		// 	ItemEntities: []admin.Item{
		// 		{
		// 			Name: to.Ptr("Test Report"),
		// 			Type: to.Ptr(admin.ItemTypeReport),
		// 			CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F771A506851"),
		// 			CreatorPrincipal: &admin.Principal{
		// 				Type: to.Ptr(admin.PrincipalTypeUser),
		// 				DisplayName: to.Ptr("Jacob Hancock"),
		// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 				UserDetails: &admin.PrincipalUserDetails{
		// 					UserPrincipalName: to.Ptr("Jacob@example.com"),
		// 				},
		// 			},
		// 			ID: to.Ptr("b1a7e572-2585-4650-98ae-b92356f4460b"),
		// 			LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-06-27T16:55:04.893Z"); return t}()),
		// 			State: to.Ptr(admin.ItemStateActive),
		// 			WorkspaceID: to.Ptr("7f4496db-9929-47bd-89c0-d7eb2f517a98"),
		// 	}},
		// }
	}
}

Output:
Example (GetAllItemsInTheTenantExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewItemsClient().NewListItemsPager(&admin.ItemsClientListItemsOptions{WorkspaceID: nil,
		CapacityID:        nil,
		State:             nil,
		Type:              nil,
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.ItemEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.Items = admin.Items{
		// 	ContinuationToken: to.Ptr("MSwxMDAwMCww"),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/items?continuationToken=MSwxMDAwMCww"),
		// 	ItemEntities: []admin.Item{
		// 		{
		// 			Name: to.Ptr("Test"),
		// 			Type: to.Ptr(admin.ItemTypeNotebook),
		// 			Description: to.Ptr("Test notebook."),
		// 			CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F771A506851"),
		// 			CreatorPrincipal: &admin.Principal{
		// 				Type: to.Ptr(admin.PrincipalTypeUser),
		// 				DisplayName: to.Ptr("Caleb Foster"),
		// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 				UserDetails: &admin.PrincipalUserDetails{
		// 					UserPrincipalName: to.Ptr("caleb@example.com"),
		// 				},
		// 			},
		// 			ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bff"),
		// 			LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-29T17:47:29.986Z"); return t}()),
		// 			State: to.Ptr(admin.ItemStateActive),
		// 			WorkspaceID: to.Ptr("7f4496db-9929-47bd-89c0-d7eb2f517a95"),
		// 		},
		// 		{
		// 			Name: to.Ptr("TestKusto"),
		// 			Type: to.Ptr(admin.ItemTypeKQLDatabase),
		// 			Description: to.Ptr("Test KQL database."),
		// 			CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F881A506851"),
		// 			CreatorPrincipal: &admin.Principal{
		// 				Type: to.Ptr(admin.PrincipalTypeUser),
		// 				DisplayName: to.Ptr("Jacob Hancock"),
		// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 				UserDetails: &admin.PrincipalUserDetails{
		// 					UserPrincipalName: to.Ptr("jacob@example.com"),
		// 				},
		// 			},
		// 			ID: to.Ptr("37d8929d-ab32-46d1-858b-fdea74e93bff"),
		// 			LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-06-30T17:47:29.986Z"); return t}()),
		// 			State: to.Ptr(admin.ItemStateActive),
		// 			WorkspaceID: to.Ptr("8f4496db-9929-47bd-89c0-d7eb2f517a95"),
		// 	}},
		// }
	}
}

Output:
Example (GetListOfDatamartsUsingTypeQueryParameterExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewItemsClient().NewListItemsPager(&admin.ItemsClientListItemsOptions{WorkspaceID: nil,
		CapacityID:        nil,
		State:             nil,
		Type:              to.Ptr("Lakehouse"),
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.ItemEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.Items = admin.Items{
		// 	ItemEntities: []admin.Item{
		// 		{
		// 			Name: to.Ptr("Lakehouse 2022-03-16T21:42:38.442Z"),
		// 			Type: to.Ptr(admin.ItemTypeLakehouse),
		// 			CapacityID: to.Ptr("D5E336D6-D919-4ECC-B424-1F771A506851"),
		// 			CreatorPrincipal: &admin.Principal{
		// 				Type: to.Ptr(admin.PrincipalTypeUser),
		// 				DisplayName: to.Ptr("Jacob Hancock"),
		// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
		// 				UserDetails: &admin.PrincipalUserDetails{
		// 					UserPrincipalName: to.Ptr("jacob@example.com"),
		// 				},
		// 			},
		// 			ID: to.Ptr("b1a7e572-2585-4650-98ae-b92356f4460b"),
		// 			LastUpdatedDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-06-27T16:55:04.893Z"); return t}()),
		// 			State: to.Ptr(admin.ItemStateActive),
		// 			WorkspaceID: to.Ptr("7f4496db-9929-47bd-89c0-d7eb2f517a98"),
		// 	}},
		// }
	}
}

Output:

type ItemsClientGetItemOptions 

type ItemsClientGetItemOptions struct {
	// The type of the item. When querying for the following types, this parameter is required:
	// * Report
	//
	//
	// * Dashboard
	//
	//
	// * SemanticModel
	//
	//
	// * App
	//
	//
	// * Dataflow
	Type *string
}

ItemsClientGetItemOptions contains the optional parameters for the ItemsClient.GetItem method.

type ItemsClientGetItemResponse 

type ItemsClientGetItemResponse struct {
	// Item details.
	Item
}

ItemsClientGetItemResponse contains the response from method ItemsClient.GetItem.

type ItemsClientListItemAccessDetailsOptions 

type ItemsClientListItemAccessDetailsOptions struct {
	// The type of the item. When querying for the following types, this parameter is required:
	// * Report
	//
	//
	// * Dashboard
	//
	//
	// * SemanticModel
	//
	//
	// * App
	//
	//
	// * Dataflow
	Type *string
}

ItemsClientListItemAccessDetailsOptions contains the optional parameters for the ItemsClient.ListItemAccessDetails method.

type ItemsClientListItemAccessDetailsResponse 

type ItemsClientListItemAccessDetailsResponse struct {
	// A list of users with access to a given entity.
	ItemAccessDetailsResponse
}

ItemsClientListItemAccessDetailsResponse contains the response from method ItemsClient.ListItemAccessDetails.

type ItemsClientListItemsOptions 

type ItemsClientListItemsOptions struct {
	// The capacity ID of the workspace.
	CapacityID *string

	// Continuous token used to get the next page items.
	ContinuationToken *string

	// The item state. Supported states are active.
	State *string

	// The item type.
	Type *string

	// The workspace ID.
	WorkspaceID *string
}

ItemsClientListItemsOptions contains the optional parameters for the ItemsClient.NewListItemsPager method.

type ItemsClientListItemsResponse 

type ItemsClientListItemsResponse struct {
	// A list of items.
	Items
}

ItemsClientListItemsResponse contains the response from method ItemsClient.NewListItemsPager.

type LabelsClient 

type LabelsClient struct {
	// contains filtered or unexported fields
}

LabelsClient contains the methods for the Labels group. Don't use this type directly, use a constructor function instead.

func (*LabelsClient) BulkRemoveLabels 

func (client *LabelsClient) BulkRemoveLabels(ctx context.Context, removeLabelsRequest RemoveLabelsRequest, options *LabelsClientBulkRemoveLabelsOptions) (LabelsClientBulkRemoveLabelsResponse, error)

BulkRemoveLabels - For a usage example, see Set or remove sensitivity labels [/power-bi/admin/service-security-sensitivity-label-inheritance-set-remove-api]. PERMISSIONS * The user must be a Fabric Administrator. * The admin user must have sufficient usage rights [/azure/information-protection/configure-usage-rights] to delete labels. REQUIRED SCOPE Tenant.ReadWrite.All LIMITATIONS * Maximum 25 requests per hour. * Each request can update up to 2,000 Fabric items. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • removeLabelsRequest - A list of items.
  • options - LabelsClientBulkRemoveLabelsOptions contains the optional parameters for the LabelsClient.BulkRemoveLabels method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLabelsClient().BulkRemoveLabels(ctx, admin.RemoveLabelsRequest{
		Items: []admin.ItemInfo{
			{
				Type: to.Ptr(admin.ItemTypeDashboard),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542a"),
			},
			{
				Type: to.Ptr(admin.ItemTypeDashboard),
				ID:   to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8b"),
			},
			{
				Type: to.Ptr(admin.ItemTypeReport),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542c"),
			},
			{
				Type: to.Ptr(admin.ItemTypeSemanticModel),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542e"),
			},
			{
				Type: to.Ptr(admin.ItemTypeNotebook),
				ID:   to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8f"),
			}},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ItemsChangeLabelResponse = admin.ItemsChangeLabelResponse{
	// 	ItemsChangeLabelStatus: []admin.ItemChangeLabelStatus{
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeDashboard),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542a"),
	// 			Status: to.Ptr(admin.StatusNotFound),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeDashboard),
	// 			ID: to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8b"),
	// 			Status: to.Ptr(admin.StatusFailed),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeReport),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542c"),
	// 			Status: to.Ptr(admin.StatusSucceeded),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeSemanticModel),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542e"),
	// 			Status: to.Ptr(admin.StatusInsufficientUsageRights),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeNotebook),
	// 			ID: to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8f"),
	// 			Status: to.Ptr(admin.StatusFailedToGetUsageRights),
	// 	}},
	// }
}

Output:

func (*LabelsClient) BulkSetLabels 

func (client *LabelsClient) BulkSetLabels(ctx context.Context, setLabelsRequest SetLabelsRequest, options *LabelsClientBulkSetLabelsOptions) (LabelsClientBulkSetLabelsResponse, error)

BulkSetLabels - To set a sensitivity label using this API the admin user or the delegated user, if provided, must have the label included in their label policy [/purview/create-sensitivity-labels?view=o365-worldwide] . For a usage example see: Set or remove sensitivity labels [/power-bi/admin/service-security-sensitivity-label-inheritance-set-remove-api]. PERMISSIONS * The user must be a Fabric Administrator. * The admin user and the delegated user, if provided, must have sufficient usage rights [/azure/information-protection/configure-usage-rights] to set labels. REQUIRED SCOPE Tenant.ReadWrite.All LIMITATIONS * Maximum 25 requests per hour. * Each request can update up to 2,000 Fabric items. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • setLabelsRequest - Set label details.
  • options - LabelsClientBulkSetLabelsOptions contains the optional parameters for the LabelsClient.BulkSetLabels method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLabelsClient().BulkSetLabels(ctx, admin.SetLabelsRequest{
		AssignmentMethod: to.Ptr(admin.AssignmentMethodStandard),
		DelegatedPrincipal: &admin.Principal{
			Type: to.Ptr(admin.PrincipalTypeUser),
			ID:   to.Ptr("796ce6ad-9163-4c16-9559-c68192a251de"),
		},
		Items: []admin.ItemInfo{
			{
				Type: to.Ptr(admin.ItemTypeDashboard),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542a"),
			},
			{
				Type: to.Ptr(admin.ItemTypeDashboard),
				ID:   to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8b"),
			},
			{
				Type: to.Ptr(admin.ItemTypeReport),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542c"),
			},
			{
				Type: to.Ptr(admin.ItemTypeSemanticModel),
				ID:   to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542e"),
			},
			{
				Type: to.Ptr(admin.ItemTypeNotebook),
				ID:   to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8f"),
			}},
		LabelID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542d"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ItemsChangeLabelResponse = admin.ItemsChangeLabelResponse{
	// 	ItemsChangeLabelStatus: []admin.ItemChangeLabelStatus{
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeDashboard),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542a"),
	// 			Status: to.Ptr(admin.StatusNotFound),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeDashboard),
	// 			ID: to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8b"),
	// 			Status: to.Ptr(admin.StatusFailed),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeReport),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542c"),
	// 			Status: to.Ptr(admin.StatusSucceeded),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeSemanticModel),
	// 			ID: to.Ptr("fe472f5e-636e-4c10-a1c6-7e9edc0b542e"),
	// 			Status: to.Ptr(admin.StatusInsufficientUsageRights),
	// 		},
	// 		{
	// 			Type: to.Ptr(admin.ItemTypeNotebook),
	// 			ID: to.Ptr("476fcafe-b514-495d-b13f-ca9a4f0b1d8f"),
	// 			Status: to.Ptr(admin.StatusFailedToGetUsageRights),
	// 	}},
	// }
}

Output:

type LabelsClientBulkRemoveLabelsOptions 

type LabelsClientBulkRemoveLabelsOptions struct {
}

LabelsClientBulkRemoveLabelsOptions contains the optional parameters for the LabelsClient.BulkRemoveLabels method.

type LabelsClientBulkRemoveLabelsResponse 

type LabelsClientBulkRemoveLabelsResponse struct {
	// A list of the unique IDs and information protection label change status of the Fabric items in the label change request.
	ItemsChangeLabelResponse
}

LabelsClientBulkRemoveLabelsResponse contains the response from method LabelsClient.BulkRemoveLabels.

type LabelsClientBulkSetLabelsOptions 

type LabelsClientBulkSetLabelsOptions struct {
}

LabelsClientBulkSetLabelsOptions contains the optional parameters for the LabelsClient.BulkSetLabels method.

type LabelsClientBulkSetLabelsResponse 

type LabelsClientBulkSetLabelsResponse struct {
	// A list of the unique IDs and information protection label change status of the Fabric items in the label change request.
	ItemsChangeLabelResponse
}

LabelsClientBulkSetLabelsResponse contains the response from method LabelsClient.BulkSetLabels.

type Principal 

type Principal struct {
	// REQUIRED; The principal's ID.
	ID *string

	// REQUIRED; The type of the principal. Additional principal types may be added over time.
	Type *PrincipalType

	// Group specific details. Applicable when the principal type is Group.
	GroupDetails *PrincipalGroupDetails

	// Service principal profile details. Applicable when the principal type is ServicePrincipalProfile.
	ServicePrincipalProfileDetails *PrincipalServicePrincipalProfileDetails

	// READ-ONLY; The principal's display name.
	DisplayName *string

	// READ-ONLY; Service principal specific details. Applicable when the principal type is ServicePrincipal.
	ServicePrincipalDetails *PrincipalServicePrincipalDetails

	// READ-ONLY; User principal specific details. Applicable when the principal type is User.
	UserDetails *PrincipalUserDetails
}

Principal - Represents an identity or a Microsoft Entra group.

func (Principal) MarshalJSON 

func (p Principal) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Principal.

func (*Principal) UnmarshalJSON 

func (p *Principal) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Principal.

type PrincipalGroupDetails 

type PrincipalGroupDetails struct {
	// The type of the group. Additional group types may be added over time.
	GroupType *GroupType
}

PrincipalGroupDetails - Group specific details. Applicable when the principal type is Group.

func (PrincipalGroupDetails) MarshalJSON 

func (p PrincipalGroupDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrincipalGroupDetails.

func (*PrincipalGroupDetails) UnmarshalJSON 

func (p *PrincipalGroupDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrincipalGroupDetails.

type PrincipalServicePrincipalDetails 

type PrincipalServicePrincipalDetails struct {
	// READ-ONLY; The service principal's Microsoft Entra AppId.
	AADAppID *string
}

PrincipalServicePrincipalDetails - Service principal specific details. Applicable when the principal type is ServicePrincipal.

func (PrincipalServicePrincipalDetails) MarshalJSON 

func (p PrincipalServicePrincipalDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrincipalServicePrincipalDetails.

func (*PrincipalServicePrincipalDetails) UnmarshalJSON 

func (p *PrincipalServicePrincipalDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrincipalServicePrincipalDetails.

type PrincipalServicePrincipalProfileDetails 

type PrincipalServicePrincipalProfileDetails struct {
	// The service principal profile's parent principal.
	ParentPrincipal *Principal
}

PrincipalServicePrincipalProfileDetails - Service principal profile details. Applicable when the principal type is ServicePrincipalProfile.

func (PrincipalServicePrincipalProfileDetails) MarshalJSON 

func (p PrincipalServicePrincipalProfileDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrincipalServicePrincipalProfileDetails.

func (*PrincipalServicePrincipalProfileDetails) UnmarshalJSON 

func (p *PrincipalServicePrincipalProfileDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrincipalServicePrincipalProfileDetails.

type PrincipalType 

type PrincipalType string

PrincipalType - The type of the principal. Additional principal types may be added over time. 

const (
	// PrincipalTypeGroup - Principal is a security group.
	PrincipalTypeGroup PrincipalType = "Group"
	// PrincipalTypeServicePrincipal - Principal is a Microsoft Entra service principal.
	PrincipalTypeServicePrincipal PrincipalType = "ServicePrincipal"
	// PrincipalTypeServicePrincipalProfile - Principal is a service principal profile.
	PrincipalTypeServicePrincipalProfile PrincipalType = "ServicePrincipalProfile"
	// PrincipalTypeUser - Principal is a Microsoft Entra user principal.
	PrincipalTypeUser PrincipalType = "User"
)

func PossiblePrincipalTypeValues 

func PossiblePrincipalTypeValues() []PrincipalType

PossiblePrincipalTypeValues returns the possible values for the PrincipalType const type.

type PrincipalUserDetails 

type PrincipalUserDetails struct {
	// READ-ONLY; The user principal name.
	UserPrincipalName *string
}

PrincipalUserDetails - User principal specific details. Applicable when the principal type is User.

func (PrincipalUserDetails) MarshalJSON 

func (p PrincipalUserDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrincipalUserDetails.

func (*PrincipalUserDetails) UnmarshalJSON 

func (p *PrincipalUserDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrincipalUserDetails.

type RemoveLabelsRequest 

type RemoveLabelsRequest struct {
	// A list of items.
	Items []ItemInfo
}

RemoveLabelsRequest - A list of items requiring an information protection label update. Each item in the list includes the item ID and Fabric item type.

func (RemoveLabelsRequest) MarshalJSON 

func (r RemoveLabelsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RemoveLabelsRequest.

func (*RemoveLabelsRequest) UnmarshalJSON 

func (r *RemoveLabelsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RemoveLabelsRequest.

type RestoreWorkspaceRequest 

type RestoreWorkspaceRequest struct {
	// The workspace's admin.
	NewWorkspaceAdminPrincipal *Principal

	// The name of the workspace. Mandatory if the restore request is for My workspace.
	NewWorkspaceName *string
}

RestoreWorkspaceRequest - The request to restore a deleted workspace.

func (RestoreWorkspaceRequest) MarshalJSON 

func (r RestoreWorkspaceRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RestoreWorkspaceRequest.

func (*RestoreWorkspaceRequest) UnmarshalJSON 

func (r *RestoreWorkspaceRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RestoreWorkspaceRequest.

type SetLabelsRequest 

type SetLabelsRequest struct {
	// REQUIRED; A list of items. The list includes item ID and type.
	Items []ItemInfo

	// REQUIRED; The label ID, which must be in the user's label policy.
	LabelID *string

	// Specifies whether the assigned label was set by an automated process or manually. Additional tenant setting property types
	// may be added over time.
	AssignmentMethod *AssignmentMethod

	// Delegated user details. A delegated user is a user within an organization whose admin sets a label on behalf of the user.
	// Although the admin sets the label, the delegated user is marked as the label
	// issuer. Only principals of type 'User' are supported.
	DelegatedPrincipal *Principal
}

SetLabelsRequest - A composite of label information required to update an information protection label.

func (SetLabelsRequest) MarshalJSON 

func (s SetLabelsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SetLabelsRequest.

func (*SetLabelsRequest) UnmarshalJSON 

func (s *SetLabelsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SetLabelsRequest.

type Status 

type Status string

Status - The status of an information protection label change operation. Additional tenant setting property types may be added over time. 

const (
	// StatusFailed - Failed to set a new label. Please retry.
	StatusFailed Status = "Failed"
	// StatusFailedToGetUsageRights - Failed to set a new label. The Fabric item has a sensitivity label with protection settings,
	// and Fabric was unable to verify that the user has sufficient usage rights to change the label.
	StatusFailedToGetUsageRights Status = "FailedToGetUsageRights"
	// StatusInsufficientUsageRights - Failed to set a new label. The Fabric item has a sensitivity label with protection settings,
	// and the admin user (and the delegated user, if provided) doesn't have sufficient usage rights to change the label.
	StatusInsufficientUsageRights Status = "InsufficientUsageRights"
	// StatusNotFound - The Fabric item ID, label or type wasn't found.
	StatusNotFound Status = "NotFound"
	// StatusSucceeded - The Fabric item label was changed.
	StatusSucceeded Status = "Succeeded"
)

func PossibleStatusValues 

func PossibleStatusValues() []Status

PossibleStatusValues returns the possible values for the Status const type.

type TenantSetting 

type TenantSetting struct {
	// REQUIRED; Indicates if the tenant setting is enabled for a security group. 0 - The tenant setting is enabled for the entire
	// organization. 1 - The tenant setting is enabled for security groups.
	CanSpecifySecurityGroups *bool

	// REQUIRED; The status of the tenant setting. 0 - Disabled, 1- Enabled.
	Enabled *bool

	// REQUIRED; The name of the tenant setting.
	SettingName *string

	// REQUIRED; The title of the tenant setting.
	Title *string

	// Indicates whether the tenant setting can be delegated to a workspace admin. False - Workspace admin cannot override the
	// tenant setting. True - Workspace admin can override the tenant setting.
	DelegateToWorkspace *bool

	// Tenant setting delegated from tenant, capacity or domain.
	DelegatedFrom *DelegatedFrom

	// A list of enabled security groups.
	EnabledSecurityGroups []TenantSettingSecurityGroup

	// A list of excluded security groups.
	ExcludedSecurityGroups []TenantSettingSecurityGroup

	// Tenant setting properties.
	Properties []TenantSettingProperty

	// Tenant setting group name.
	TenantSettingGroup *string
}

TenantSetting - Tenant setting details.

func (TenantSetting) MarshalJSON 

func (t TenantSetting) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSetting.

func (*TenantSetting) UnmarshalJSON 

func (t *TenantSetting) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSetting.

type TenantSettingOverride 

type TenantSettingOverride struct {
	// The ID of a capacity, domain or workspace.
	ID *string

	// A list of tenant settings.
	TenantSettings []TenantSetting
}

TenantSettingOverride - A workspace, capacity or domain admin can override the tenant setting.

func (TenantSettingOverride) MarshalJSON 

func (t TenantSettingOverride) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSettingOverride.

func (*TenantSettingOverride) UnmarshalJSON 

func (t *TenantSettingOverride) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSettingOverride.

type TenantSettingOverrides 

type TenantSettingOverrides struct {
	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string

	// A list of tenant settings that were overridden by a workspace, capacity or domain admin.
	Overrides []TenantSettingOverride
}

TenantSettingOverrides - A list of tenant settings overrides.

func (TenantSettingOverrides) MarshalJSON 

func (t TenantSettingOverrides) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSettingOverrides.

func (*TenantSettingOverrides) UnmarshalJSON 

func (t *TenantSettingOverrides) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSettingOverrides.

type TenantSettingProperty 

type TenantSettingProperty struct {
	// The name of the property.
	Name *string

	// The type of the property.
	Type *TenantSettingPropertyType

	// The value of the property.
	Value *string
}

TenantSettingProperty - Tenant setting property.

func (TenantSettingProperty) MarshalJSON 

func (t TenantSettingProperty) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSettingProperty.

func (*TenantSettingProperty) UnmarshalJSON 

func (t *TenantSettingProperty) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSettingProperty.

type TenantSettingPropertyType 

type TenantSettingPropertyType string

TenantSettingPropertyType - Tenant setting property type. Additional tenant setting property types may be added over time. 

const (
	// TenantSettingPropertyTypeBoolean - A checkbox in the UI.
	TenantSettingPropertyTypeBoolean TenantSettingPropertyType = "Boolean"
	// TenantSettingPropertyTypeFreeText - UI accepts any string for the text box.
	TenantSettingPropertyTypeFreeText TenantSettingPropertyType = "FreeText"
	// TenantSettingPropertyTypeInteger - UI accepts only integers for the text box.
	TenantSettingPropertyTypeInteger TenantSettingPropertyType = "Integer"
	// TenantSettingPropertyTypeMailEnabledSecurityGroup - UI accepts only email enabled security groups for the text box.
	TenantSettingPropertyTypeMailEnabledSecurityGroup TenantSettingPropertyType = "MailEnabledSecurityGroup"
	// TenantSettingPropertyTypeURL - UI accepts only URLs for the text box.
	TenantSettingPropertyTypeURL TenantSettingPropertyType = "Url"
)

func PossibleTenantSettingPropertyTypeValues 

func PossibleTenantSettingPropertyTypeValues() []TenantSettingPropertyType

PossibleTenantSettingPropertyTypeValues returns the possible values for the TenantSettingPropertyType const type.

type TenantSettingSecurityGroup 

type TenantSettingSecurityGroup struct {
	// REQUIRED; The graph ID of the security group.
	GraphID *string

	// REQUIRED; The name of the security group.
	Name *string
}

TenantSettingSecurityGroup - Tenant setting security group.

func (TenantSettingSecurityGroup) MarshalJSON 

func (t TenantSettingSecurityGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSettingSecurityGroup.

func (*TenantSettingSecurityGroup) UnmarshalJSON 

func (t *TenantSettingSecurityGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSettingSecurityGroup.

type TenantSettings 

type TenantSettings struct {
	// A list of tenant settings.
	TenantSettings []TenantSetting
}

TenantSettings - A list of tenant settings.

func (TenantSettings) MarshalJSON 

func (t TenantSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TenantSettings.

func (*TenantSettings) UnmarshalJSON 

func (t *TenantSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TenantSettings.

type TenantsClient 

type TenantsClient struct {
	// contains filtered or unexported fields
}

TenantsClient contains the methods for the Tenants group. Don't use this type directly, use a constructor function instead.

func (*TenantsClient) ListCapacitiesTenantSettingsOverrides 

func (client *TenantsClient) ListCapacitiesTenantSettingsOverrides(ctx context.Context, options *TenantsClientListCapacitiesTenantSettingsOverridesOptions) ([]TenantSettingOverride, error)

ListCapacitiesTenantSettingsOverrides - returns array of TenantSettingOverride from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuation token provided in the response, you can get the next 10,000 records.

The user must be a Fabric Service Administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All

LIMITATIONS Maximum 100 requests per hour.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • options - TenantsClientListCapacitiesTenantSettingsOverridesOptions contains the optional parameters for the TenantsClient.NewListCapacitiesTenantSettingsOverridesPager method.

func (*TenantsClient) ListTenantSettings 

func (client *TenantsClient) ListTenantSettings(ctx context.Context, options *TenantsClientListTenantSettingsOptions) (TenantsClientListTenantSettingsResponse, error)

ListTenantSettings - PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • options - TenantsClientListTenantSettingsOptions contains the optional parameters for the TenantsClient.ListTenantSettings method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewTenantsClient().ListTenantSettings(ctx, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.TenantSettings = admin.TenantSettings{
	// 	TenantSettings: []admin.TenantSetting{
	// 		{
	// 			CanSpecifySecurityGroups: to.Ptr(true),
	// 			Enabled: to.Ptr(true),
	// 			SettingName: to.Ptr("AdminApisIncludeDetailedMetadata"),
	// 			TenantSettingGroup: to.Ptr("AdminApiSettings"),
	// 			Title: to.Ptr("Enhance admin APIs responses with detailed metadata"),
	// 		},
	// 		{
	// 			CanSpecifySecurityGroups: to.Ptr(true),
	// 			Enabled: to.Ptr(true),
	// 			EnabledSecurityGroups: []admin.TenantSettingSecurityGroup{
	// 				{
	// 					Name: to.Ptr("TestComputeCdsa"),
	// 					GraphID: to.Ptr("f51b705f-a409-4d40-9197-c5d5f349e2f0"),
	// 				},
	// 				{
	// 					Name: to.Ptr("TestComputeGroup2"),
	// 					GraphID: to.Ptr("1fecf19f-6e33-41b3-89fa-de8c821f3b79"),
	// 				},
	// 				{
	// 					Name: to.Ptr("TestCertifiers"),
	// 					GraphID: to.Ptr("64bc10f1-1f1b-4a7e-b7a0-c87d89cba2b4"),
	// 			}},
	// 			SettingName: to.Ptr("DatamartTenant"),
	// 			TenantSettingGroup: to.Ptr("DatamartSettings"),
	// 			Title: to.Ptr("Create Datamarts (Preview)"),
	// 		},
	// 		{
	// 			CanSpecifySecurityGroups: to.Ptr(true),
	// 			Enabled: to.Ptr(true),
	// 			SettingName: to.Ptr("CertifyDatasets"),
	// 			TenantSettingGroup: to.Ptr("ExportAndSharing"),
	// 			Title: to.Ptr("Certification"),
	// 	}},
	// }
}

Output:

func (*TenantsClient) NewListCapacitiesTenantSettingsOverridesPager 

func (client *TenantsClient) NewListCapacitiesTenantSettingsOverridesPager(options *TenantsClientListCapacitiesTenantSettingsOverridesOptions) *runtime.Pager[TenantsClientListCapacitiesTenantSettingsOverridesResponse]

NewListCapacitiesTenantSettingsOverridesPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuation token provided in the response, you can get the next 10,000 records. The user must be a Fabric Service Administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 100 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • options - TenantsClientListCapacitiesTenantSettingsOverridesOptions contains the optional parameters for the TenantsClient.NewListCapacitiesTenantSettingsOverridesPager method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewTenantsClient().NewListCapacitiesTenantSettingsOverridesPager(&admin.TenantsClientListCapacitiesTenantSettingsOverridesOptions{ContinuationToken: nil})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Overrides {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.TenantSettingOverrides = admin.TenantSettingOverrides{
		// 	ContinuationToken: to.Ptr("MSwxMDAwMCww"),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/capacities/delegatedTenantSettingOverrides?continuationToken=MSwxMDAwMCww"),
		// 	Overrides: []admin.TenantSettingOverride{
		// 		{
		// 			ID: to.Ptr("f51b705f-a409-4d40-9197-c5d5f349e2ef"),
		// 			TenantSettings: []admin.TenantSetting{
		// 				{
		// 					CanSpecifySecurityGroups: to.Ptr(true),
		// 					DelegateToWorkspace: to.Ptr(false),
		// 					DelegatedFrom: to.Ptr(admin.DelegatedFromTenant),
		// 					Enabled: to.Ptr(true),
		// 					EnabledSecurityGroups: []admin.TenantSettingSecurityGroup{
		// 						{
		// 							Name: to.Ptr("TestComputeCdsa"),
		// 							GraphID: to.Ptr("f51b705f-a409-4d40-9197-c5d5f349e2f0"),
		// 						},
		// 						{
		// 							Name: to.Ptr("TestComputeGroup2"),
		// 							GraphID: to.Ptr("1fecf19f-6e33-41b3-89fa-de8c821f3b79"),
		// 						},
		// 						{
		// 							Name: to.Ptr("TestCertifiers"),
		// 							GraphID: to.Ptr("64bc10f1-1f1b-4a7e-b7a0-c87d89cba2b4"),
		// 					}},
		// 					Properties: []admin.TenantSettingProperty{
		// 						{
		// 							Name: to.Ptr("testIntProp"),
		// 							Type: to.Ptr(admin.TenantSettingPropertyTypeInteger),
		// 							Value: to.Ptr("5"),
		// 					}},
		// 					SettingName: to.Ptr("TenantSettingForCapacityDelegatedSwitch"),
		// 					TenantSettingGroup: to.Ptr("Delegation testing"),
		// 					Title: to.Ptr("Capacity delegation test settings"),
		// 			}},
		// 	}},
		// }
	}
}

Output:

type TenantsClientListCapacitiesTenantSettingsOverridesOptions 

type TenantsClientListCapacitiesTenantSettingsOverridesOptions struct {
	// A token for retrieving the next page of results.
	ContinuationToken *string
}

TenantsClientListCapacitiesTenantSettingsOverridesOptions contains the optional parameters for the TenantsClient.NewListCapacitiesTenantSettingsOverridesPager method.

type TenantsClientListCapacitiesTenantSettingsOverridesResponse 

type TenantsClientListCapacitiesTenantSettingsOverridesResponse struct {
	// A list of tenant settings overrides.
	TenantSettingOverrides
}

TenantsClientListCapacitiesTenantSettingsOverridesResponse contains the response from method TenantsClient.NewListCapacitiesTenantSettingsOverridesPager.

type TenantsClientListTenantSettingsOptions 

type TenantsClientListTenantSettingsOptions struct {
}

TenantsClientListTenantSettingsOptions contains the optional parameters for the TenantsClient.ListTenantSettings method.

type TenantsClientListTenantSettingsResponse 

type TenantsClientListTenantSettingsResponse struct {
	// A list of tenant settings.
	TenantSettings
}

TenantsClientListTenantSettingsResponse contains the response from method TenantsClient.ListTenantSettings.

type UnassignDomainWorkspacesByIDsRequest 

type UnassignDomainWorkspacesByIDsRequest struct {
	WorkspacesIDs []string
}

UnassignDomainWorkspacesByIDsRequest - The request payload for unassigning workspaces from a domain by workspace ID.

func (UnassignDomainWorkspacesByIDsRequest) MarshalJSON 

func (u UnassignDomainWorkspacesByIDsRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UnassignDomainWorkspacesByIDsRequest.

func (*UnassignDomainWorkspacesByIDsRequest) UnmarshalJSON 

func (u *UnassignDomainWorkspacesByIDsRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UnassignDomainWorkspacesByIDsRequest.

type UpdateDomainRequest 

type UpdateDomainRequest struct {
	// The domain contributors scope.
	ContributorsScope *ContributorsScopeType

	// The domain description. The description cannot contain more than 256 characters.
	Description *string

	// The domain display name. The display name cannot contain more than 40 characters.
	DisplayName *string
}

UpdateDomainRequest - The request payload for updating a domain.

func (UpdateDomainRequest) MarshalJSON 

func (u UpdateDomainRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpdateDomainRequest.

func (*UpdateDomainRequest) UnmarshalJSON 

func (u *UpdateDomainRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDomainRequest.

type UsersClient 

type UsersClient struct {
	// contains filtered or unexported fields
}

UsersClient contains the methods for the Users group. Don't use this type directly, use a constructor function instead.

func (*UsersClient) ListAccessEntities 

func (client *UsersClient) ListAccessEntities(ctx context.Context, userID string, options *UsersClientListAccessEntitiesOptions) ([]AccessEntity, error)

ListAccessEntities - returns array of AccessEntity from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records.

Page order:

  1. Fabric items
  2. Datamarts
  3. Reports
  4. Dashboards
  5. SemanticModels
  6. Apps
  7. Dataflows

PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All

LIMITATIONS Maximum 200 requests per hour.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • userID - The user graph ID or User Principal Name (UPN).
  • options - UsersClientListAccessEntitiesOptions contains the optional parameters for the UsersClient.NewListAccessEntitiesPager method.

func (*UsersClient) NewListAccessEntitiesPager 

func (client *UsersClient) NewListAccessEntitiesPager(userID string, options *UsersClientListAccessEntitiesOptions) *runtime.Pager[UsersClientListAccessEntitiesResponse]

NewListAccessEntitiesPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records. Page order: 1. Fabric items 2. Datamarts 3. Reports 4. Dashboards 5. SemanticModels 6. Apps 7. Dataflows PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • userID - The user graph ID or User Principal Name (UPN).
  • options - UsersClientListAccessEntitiesOptions contains the optional parameters for the UsersClient.NewListAccessEntitiesPager method.
Example (ListItemAccessDetailsByGraphIdAndTypeQueryParameterExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewUsersClient().NewListAccessEntitiesPager("f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.UsersClientListAccessEntitiesOptions{Type: to.Ptr("Report"),
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.AccessEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AccessEntityResponse = admin.AccessEntityResponse{
		// 	AccessEntities: []admin.AccessEntity{
		// 		{
		// 			Category: to.Ptr(admin.CategoryItem),
		// 			DisplayName: to.Ptr("Test Report"),
		// 			ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
		// 			ItemAccessDetails: &admin.ItemAccessDetail{
		// 				Type: to.Ptr(admin.ItemTypeReport),
		// 				AdditionalPermissions: []string{
		// 					"ReadAll",
		// 					"viewOutput"},
		// 					Permissions: []admin.ItemPermissions{
		// 						admin.ItemPermissionsRead,
		// 						admin.ItemPermissionsReshare},
		// 					},
		// 			}},
		// 		}
	}
}

Output:
Example (ListItemAccessDetailsByGraphIdExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewUsersClient().NewListAccessEntitiesPager("f089354e-8366-4e18-aea3-4cb4a3a50b48", &admin.UsersClientListAccessEntitiesOptions{Type: nil,
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.AccessEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AccessEntityResponse = admin.AccessEntityResponse{
		// 	ContinuationToken: to.Ptr("MSwxMDAwMCww"),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/users/f3052d1c-61a9-46fb-8df9-0d78916ae041/access/?continuationToken=MSwxMDAwMCww"),
		// 	AccessEntities: []admin.AccessEntity{
		// 		{
		// 			Category: to.Ptr(admin.CategoryItem),
		// 			DisplayName: to.Ptr("TestNotebook"),
		// 			ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
		// 			ItemAccessDetails: &admin.ItemAccessDetail{
		// 				Type: to.Ptr(admin.ItemTypeNotebook),
		// 				AdditionalPermissions: []string{
		// 					"ReadAll",
		// 					"viewOutput"},
		// 					Permissions: []admin.ItemPermissions{
		// 						admin.ItemPermissionsRead,
		// 						admin.ItemPermissionsReshare,
		// 						admin.ItemPermissionsExplore},
		// 					},
		// 			}},
		// 		}
	}
}

Output:
Example (ListItemAccessDetailsByUserPrincipalNameUpnExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewUsersClient().NewListAccessEntitiesPager("Test@Contoso.com", &admin.UsersClientListAccessEntitiesOptions{Type: nil,
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.AccessEntities {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AccessEntityResponse = admin.AccessEntityResponse{
		// 	ContinuationToken: to.Ptr("MSwxMDAwMCww"),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/users/f3052d1c-61a9-46fb-8df9-0d78916ae041/access/?continuationToken=MSwxMDAwMCww"),
		// 	AccessEntities: []admin.AccessEntity{
		// 		{
		// 			Category: to.Ptr(admin.CategoryItem),
		// 			DisplayName: to.Ptr("TestNotebook"),
		// 			ID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
		// 			ItemAccessDetails: &admin.ItemAccessDetail{
		// 				Type: to.Ptr(admin.ItemTypeNotebook),
		// 				AdditionalPermissions: []string{
		// 					"ReadAll",
		// 					"viewOutput"},
		// 					Permissions: []admin.ItemPermissions{
		// 						admin.ItemPermissionsRead,
		// 						admin.ItemPermissionsReshare,
		// 						admin.ItemPermissionsExplore},
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type UsersClientListAccessEntitiesOptions 

type UsersClientListAccessEntitiesOptions struct {
	// Continuous token used to get the next page items.
	ContinuationToken *string

	// The item type.
	Type *string
}

UsersClientListAccessEntitiesOptions contains the optional parameters for the UsersClient.NewListAccessEntitiesPager method.

type UsersClientListAccessEntitiesResponse 

type UsersClientListAccessEntitiesResponse struct {
	// A list of entities and permissions.
	AccessEntityResponse
}

UsersClientListAccessEntitiesResponse contains the response from method UsersClient.NewListAccessEntitiesPager.

type Workspace 

type Workspace struct {
	// REQUIRED; The workspace name.
	Name *string

	// READ-ONLY; The workspace ID.
	ID *string

	// READ-ONLY; The workspace state.
	State *WorkspaceState

	// READ-ONLY; The workspace type.
	Type *WorkspaceType

	// READ-ONLY; The capacity ID of the workspace.
	CapacityID *string
}

Workspace.

func (Workspace) MarshalJSON 

func (w Workspace) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Workspace.

func (*Workspace) UnmarshalJSON 

func (w *Workspace) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Workspace.

type WorkspaceAccessDetail 

type WorkspaceAccessDetail struct {
	// The workspace role.
	WorkspaceRole *WorkspaceRole

	// READ-ONLY; Workspace type.
	Type *WorkspaceType
}

WorkspaceAccessDetail - Workspace permission details.

func (WorkspaceAccessDetail) MarshalJSON 

func (w WorkspaceAccessDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceAccessDetail.

func (*WorkspaceAccessDetail) UnmarshalJSON 

func (w *WorkspaceAccessDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceAccessDetail.

type WorkspaceAccessDetails 

type WorkspaceAccessDetails struct {
	// READ-ONLY; Information regarding the user who has access to the entity.
	Principal *Principal

	// READ-ONLY; Workspace permissions for the user.
	WorkspaceAccessDetails *WorkspaceAccessDetail
}

WorkspaceAccessDetails - User access details for the workspace.

func (WorkspaceAccessDetails) MarshalJSON 

func (w WorkspaceAccessDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceAccessDetails.

func (*WorkspaceAccessDetails) UnmarshalJSON 

func (w *WorkspaceAccessDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceAccessDetails.

type WorkspaceAccessDetailsResponse 

type WorkspaceAccessDetailsResponse struct {
	// A list of users with access to an entity.
	AccessDetails []WorkspaceAccessDetails
}

WorkspaceAccessDetailsResponse - A list of users with access to a given entity.

func (WorkspaceAccessDetailsResponse) MarshalJSON 

func (w WorkspaceAccessDetailsResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkspaceAccessDetailsResponse.

func (*WorkspaceAccessDetailsResponse) UnmarshalJSON 

func (w *WorkspaceAccessDetailsResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkspaceAccessDetailsResponse.

type WorkspaceRole 

type WorkspaceRole string

WorkspaceRole - A Workspace role. Additional workspace roles may be added over time. 

const (
	// WorkspaceRoleAdmin - Enables administrative access to the workspace.
	WorkspaceRoleAdmin WorkspaceRole = "Admin"
	// WorkspaceRoleContributor - Enables contribution to the workspace.
	WorkspaceRoleContributor WorkspaceRole = "Contributor"
	// WorkspaceRoleMember - Enables membership access to the workspace.
	WorkspaceRoleMember WorkspaceRole = "Member"
	// WorkspaceRoleViewer - Enables viewing of the workspace.
	WorkspaceRoleViewer WorkspaceRole = "Viewer"
)

func PossibleWorkspaceRoleValues 

func PossibleWorkspaceRoleValues() []WorkspaceRole

PossibleWorkspaceRoleValues returns the possible values for the WorkspaceRole const type.

type WorkspaceState 

type WorkspaceState string

WorkspaceState - The workspace state. Additional workspace states may be added over time. 

const (
	// WorkspaceStateActive - The workspace is active. Orphaned workspaces are displayed as active.
	WorkspaceStateActive WorkspaceState = "Active"
	// WorkspaceStateDeleted - The workspace is deleted.
	WorkspaceStateDeleted WorkspaceState = "Deleted"
)

func PossibleWorkspaceStateValues 

func PossibleWorkspaceStateValues() []WorkspaceState

PossibleWorkspaceStateValues returns the possible values for the WorkspaceState const type.

type WorkspaceType 

type WorkspaceType string

WorkspaceType - A workspace type. Additional workspace types may be added over time. 

const (
	// WorkspaceTypeAdminWorkspace - Admin monitoring workspace. Contains admin reports such as the audit report and the usage
	// and adoption report.
	WorkspaceTypeAdminWorkspace WorkspaceType = "AdminWorkspace"
	// WorkspaceTypePersonal - My folder or My workspace used to manage user items.
	WorkspaceTypePersonal WorkspaceType = "Personal"
	// WorkspaceTypeWorkspace - Workspace used to manage the Fabric items.
	WorkspaceTypeWorkspace WorkspaceType = "Workspace"
)

func PossibleWorkspaceTypeValues 

func PossibleWorkspaceTypeValues() []WorkspaceType

PossibleWorkspaceTypeValues returns the possible values for the WorkspaceType const type.

type Workspaces 

type Workspaces struct {
	// The token for the next result set batch. If there are no more records, it's removed from the response.
	ContinuationToken *string

	// The URI of the next result set batch. If there are no more records, it's removed from the response.
	ContinuationURI *string

	// The list of fabric workspaces.
	Workspaces []Workspace
}

Workspaces - A list of workspaces.

func (Workspaces) MarshalJSON 

func (w Workspaces) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Workspaces.

func (*Workspaces) UnmarshalJSON 

func (w *Workspaces) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Workspaces.

type WorkspacesClient 

type WorkspacesClient struct {
	// contains filtered or unexported fields
}

WorkspacesClient contains the methods for the Workspaces group. Don't use this type directly, use a constructor function instead.

func (*WorkspacesClient) GetWorkspace 

func (client *WorkspacesClient) GetWorkspace(ctx context.Context, workspaceID string, options *WorkspacesClientGetWorkspaceOptions) (WorkspacesClientGetWorkspaceResponse, error)

GetWorkspace - PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • options - WorkspacesClientGetWorkspaceOptions contains the optional parameters for the WorkspacesClient.GetWorkspace method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspacesClient().GetWorkspace(ctx, "f089354e-8366-4e18-aea3-4cb4a3a50b48", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Workspace = admin.Workspace{
	// 	Name: to.Ptr("test report"),
	// 	Type: to.Ptr(admin.WorkspaceTypeWorkspace),
	// 	CapacityID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e84"),
	// 	ID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e87"),
	// 	State: to.Ptr(admin.WorkspaceStateActive),
	// }
}

Output:

func (*WorkspacesClient) ListGitConnections 

func (client *WorkspacesClient) ListGitConnections(ctx context.Context, options *WorkspacesClientListGitConnectionsOptions) ([]GitConnectionDetails, error)

ListGitConnections - returns array of GitConnectionDetails from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 1,000 records can be returned per request. With the continuous token provided in the response, you can get the next 1,000 records.

PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All

LIMITATIONS Maximum 25 requests per minute.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | |

INTERFACE Generated from API version v1

  • options - WorkspacesClientListGitConnectionsOptions contains the optional parameters for the WorkspacesClient.NewListGitConnectionsPager method.

func (*WorkspacesClient) ListWorkspaceAccessDetails 

func (client *WorkspacesClient) ListWorkspaceAccessDetails(ctx context.Context, workspaceID string, options *WorkspacesClientListWorkspaceAccessDetailsOptions) (WorkspacesClientListWorkspaceAccessDetailsResponse, error)

ListWorkspaceAccessDetails - PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • options - WorkspacesClientListWorkspaceAccessDetailsOptions contains the optional parameters for the WorkspacesClient.ListWorkspaceAccessDetails method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewWorkspacesClient().ListWorkspaceAccessDetails(ctx, "f089354e-8366-4e18-aea3-4cb4a3a50b48", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.WorkspaceAccessDetailsResponse = admin.WorkspaceAccessDetailsResponse{
	// 	AccessDetails: []admin.WorkspaceAccessDetails{
	// 		{
	// 			Principal: &admin.Principal{
	// 				Type: to.Ptr(admin.PrincipalTypeUser),
	// 				DisplayName: to.Ptr("Jacob Hancock"),
	// 				ID: to.Ptr("f3052d1c-61a9-46fb-8df9-0d78916ae041"),
	// 				UserDetails: &admin.PrincipalUserDetails{
	// 					UserPrincipalName: to.Ptr("jacob@example.com"),
	// 				},
	// 			},
	// 			WorkspaceAccessDetails: &admin.WorkspaceAccessDetail{
	// 				Type: to.Ptr(admin.WorkspaceTypeWorkspace),
	// 				WorkspaceRole: to.Ptr(admin.WorkspaceRoleAdmin),
	// 			},
	// 		},
	// 		{
	// 			Principal: &admin.Principal{
	// 				Type: to.Ptr(admin.PrincipalTypeUser),
	// 				DisplayName: to.Ptr("Caleb Foster"),
	// 				ID: to.Ptr("c7db8e03-c8cb-4d4c-9f64-1dcd327c9d3c"),
	// 				UserDetails: &admin.PrincipalUserDetails{
	// 					UserPrincipalName: to.Ptr("caleb@example.com"),
	// 				},
	// 			},
	// 			WorkspaceAccessDetails: &admin.WorkspaceAccessDetail{
	// 				Type: to.Ptr(admin.WorkspaceTypeWorkspace),
	// 				WorkspaceRole: to.Ptr(admin.WorkspaceRoleViewer),
	// 			},
	// 		},
	// 		{
	// 			Principal: &admin.Principal{
	// 				Type: to.Ptr(admin.PrincipalTypeGroup),
	// 				DisplayName: to.Ptr("TestSecurityGroup"),
	// 				GroupDetails: &admin.PrincipalGroupDetails{
	// 					GroupType: to.Ptr(admin.GroupTypeSecurityGroup),
	// 				},
	// 				ID: to.Ptr("f51b705f-a409-4d40-9197-c5d5f349e2f0"),
	// 			},
	// 			WorkspaceAccessDetails: &admin.WorkspaceAccessDetail{
	// 				Type: to.Ptr(admin.WorkspaceTypeWorkspace),
	// 				WorkspaceRole: to.Ptr(admin.WorkspaceRoleContributor),
	// 			},
	// 	}},
	// }
}

Output:

func (*WorkspacesClient) ListWorkspaces 

func (client *WorkspacesClient) ListWorkspaces(ctx context.Context, options *WorkspacesClientListWorkspacesOptions) ([]Workspace, error)

ListWorkspaces - returns array of Workspace from all pages. This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records.

PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal.

REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All

LIMITATIONS Maximum 200 requests per hour.

MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section.

| Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes |

INTERFACE Generated from API version v1

  • options - WorkspacesClientListWorkspacesOptions contains the optional parameters for the WorkspacesClient.NewListWorkspacesPager method.

func (*WorkspacesClient) NewListGitConnectionsPager 

func (client *WorkspacesClient) NewListGitConnectionsPager(options *WorkspacesClientListGitConnectionsOptions) *runtime.Pager[WorkspacesClientListGitConnectionsResponse]

NewListGitConnectionsPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 1,000 records can be returned per request. With the continuous token provided in the response, you can get the next 1,000 records. PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 25 requests per minute. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | | INTERFACE

Generated from API version v1

  • options - WorkspacesClientListGitConnectionsOptions contains the optional parameters for the WorkspacesClient.NewListGitConnectionsPager method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkspacesClient().NewListGitConnectionsPager(&admin.WorkspacesClientListGitConnectionsOptions{ContinuationToken: nil})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.GitConnections = admin.GitConnections{
		// 	ContinuationToken: to.Ptr("eyJMYXN0U2VlbkNvbm5lY3Rpb25JZCI6NX0="),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/workspaces/discoverGitConnections?continuationToken=eyJMYXN0U2VlbkNvbm5lY3Rpb25JZCI6NX0="),
		// 	Value: []admin.GitConnectionDetails{
		// 		{
		// 			GitProviderDetails: &admin.AzureDevOpsDetails{
		// 				BranchName: to.Ptr("Test Branch"),
		// 				DirectoryName: to.Ptr("/Test Directory"),
		// 				GitProviderType: to.Ptr(admin.GitProviderTypeAzureDevOps),
		// 				RepositoryName: to.Ptr("Test Repo"),
		// 				OrganizationName: to.Ptr("Test Organization"),
		// 				ProjectName: to.Ptr("Test Project"),
		// 			},
		// 			WorkspaceID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e87"),
		// 		},
		// 		{
		// 			GitProviderDetails: &admin.GitHubDetails{
		// 				BranchName: to.Ptr("Test Branch"),
		// 				DirectoryName: to.Ptr("/"),
		// 				GitProviderType: to.Ptr(admin.GitProviderTypeGitHub),
		// 				RepositoryName: to.Ptr("Test Repo"),
		// 				OwnerName: to.Ptr("Test Owner"),
		// 			},
		// 			WorkspaceID: to.Ptr("17d8929d-ab32-46d1-858b-fdea74e93bf2"),
		// 	}},
		// }
	}
}

Output:

func (*WorkspacesClient) NewListWorkspacesPager 

func (client *WorkspacesClient) NewListWorkspacesPager(options *WorkspacesClientListWorkspacesOptions) *runtime.Pager[WorkspacesClientListWorkspacesResponse]

NewListWorkspacesPager - This API supports pagination [/rest/api/fabric/articles/pagination]. A maximum of 10,000 records can be returned per request. With the continuous token provided in the response, you can get the next 10,000 records. PERMISSIONS The caller must be a Fabric administrator or authenticate using a service principal. REQUIRED DELEGATED SCOPES Tenant.Read.All or Tenant.ReadWrite.All LIMITATIONS Maximum 200 requests per hour. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | Yes | INTERFACE

Generated from API version v1

  • options - WorkspacesClientListWorkspacesOptions contains the optional parameters for the WorkspacesClient.NewListWorkspacesPager method.
Example (GetAListOfWorkspacesExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkspacesClient().NewListWorkspacesPager(&admin.WorkspacesClientListWorkspacesOptions{Type: nil,
		CapacityID:        nil,
		Name:              nil,
		State:             nil,
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Workspaces.Workspaces {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.Workspaces = admin.Workspaces{
		// 	ContinuationToken: to.Ptr("LDEsMTAwMDAwLDA%3D"),
		// 	ContinuationURI: to.Ptr("https://api.fabric.microsoft.com/v1/admin/workspaces?continuationToken='LDEsMTAwMDAwLDA%3D'"),
		// 	Workspaces: []admin.Workspace{
		// 		{
		// 			Name: to.Ptr("test report"),
		// 			Type: to.Ptr(admin.WorkspaceTypeWorkspace),
		// 			CapacityID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e84"),
		// 			ID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e87"),
		// 			State: to.Ptr(admin.WorkspaceStateActive),
		// 	}},
		// }
	}
}

Output:
Example (GetAListOfWorkspacesUsingStateQueryParameterExample)

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewWorkspacesClient().NewListWorkspacesPager(&admin.WorkspacesClientListWorkspacesOptions{Type: nil,
		CapacityID:        nil,
		Name:              nil,
		State:             to.Ptr("Active"),
		ContinuationToken: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Workspaces.Workspaces {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.Workspaces = admin.Workspaces{
		// 	Workspaces: []admin.Workspace{
		// 		{
		// 			Name: to.Ptr("test report"),
		// 			Type: to.Ptr(admin.WorkspaceTypeWorkspace),
		// 			CapacityID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e84"),
		// 			ID: to.Ptr("41ce06d1-d81b-4ea0-bc6d-2ce3dd2f8e87"),
		// 			State: to.Ptr(admin.WorkspaceStateActive),
		// 	}},
		// }
	}
}

Output:

func (*WorkspacesClient) RestoreWorkspace 

func (client *WorkspacesClient) RestoreWorkspace(ctx context.Context, workspaceID string, restoreWorkspaceRequest RestoreWorkspaceRequest, options *WorkspacesClientRestoreWorkspaceOptions) (WorkspacesClientRestoreWorkspaceResponse, error)

RestoreWorkspace - PERMISSIONS The caller must have Fabric administrator rights. REQUIRED DELEGATED SCOPES Tenant.ReadWrite.All. LIMITATIONS Maximum ten requests per minute. MICROSOFT ENTRA SUPPORTED IDENTITIES This API supports the Microsoft identities [/rest/api/fabric/articles/identity-support] listed in this section. | Identity | Support | |-|-| | User | Yes | | Service principal [/entra/identity-platform/app-objects-and-service-principals#service-principal-object] and Managed identities [/entra/identity/managed-identities-azure-resources/overview] | No | INTERFACE If the operation fails it returns an *core.ResponseError type.

Generated from API version v1

  • workspaceID - The workspace ID.
  • restoreWorkspaceRequest - The request payload for restoring the deleted workspace.
  • options - WorkspacesClientRestoreWorkspaceOptions contains the optional parameters for the WorkspacesClient.RestoreWorkspace method.
Example

Generated from example definition 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"

	"github.com/microsoft/fabric-sdk-go/fabric/admin"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := admin.NewClientFactory(cred, nil, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewWorkspacesClient().RestoreWorkspace(ctx, "97dd1d38-a4c6-41ed-bc4f-1e383f8ddd0f", admin.RestoreWorkspaceRequest{
		NewWorkspaceAdminPrincipal: &admin.Principal{
			Type: to.Ptr(admin.PrincipalTypeUser),
			ID:   to.Ptr("17dd1e38-a4c6-41ed-bc4f-1e383f8ddd01"),
		},
		NewWorkspaceName: to.Ptr("Contoso Workspace"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

type WorkspacesClientGetWorkspaceOptions 

type WorkspacesClientGetWorkspaceOptions struct {
}

WorkspacesClientGetWorkspaceOptions contains the optional parameters for the WorkspacesClient.GetWorkspace method.

type WorkspacesClientGetWorkspaceResponse 

type WorkspacesClientGetWorkspaceResponse struct {
	// Workspace.
	Workspace
}

WorkspacesClientGetWorkspaceResponse contains the response from method WorkspacesClient.GetWorkspace.

type WorkspacesClientListGitConnectionsOptions 

type WorkspacesClientListGitConnectionsOptions struct {
	// A token for retrieving the next page of results.
	ContinuationToken *string
}

WorkspacesClientListGitConnectionsOptions contains the optional parameters for the WorkspacesClient.NewListGitConnectionsPager method.

type WorkspacesClientListGitConnectionsResponse 

type WorkspacesClientListGitConnectionsResponse struct {
	// A response wrapper for a list of all the Git connections for a given tenant with a continuous token.
	GitConnections
}

WorkspacesClientListGitConnectionsResponse contains the response from method WorkspacesClient.NewListGitConnectionsPager.

type WorkspacesClientListWorkspaceAccessDetailsOptions 

type WorkspacesClientListWorkspaceAccessDetailsOptions struct {
}

WorkspacesClientListWorkspaceAccessDetailsOptions contains the optional parameters for the WorkspacesClient.ListWorkspaceAccessDetails method.

type WorkspacesClientListWorkspaceAccessDetailsResponse 

type WorkspacesClientListWorkspaceAccessDetailsResponse struct {
	// A list of users with access to a given entity.
	WorkspaceAccessDetailsResponse
}

WorkspacesClientListWorkspaceAccessDetailsResponse contains the response from method WorkspacesClient.ListWorkspaceAccessDetails.

type WorkspacesClientListWorkspacesOptions 

type WorkspacesClientListWorkspacesOptions struct {
	// The capacity ID of the workspace.
	CapacityID *string

	// Continuation token. Used to get the next items in the list.
	ContinuationToken *string

	// The workspace name.
	Name *string

	// The workspace state. Supported states are active and deleted.
	State *string

	// The workspace type. Supported types are personal, workspace, adminworkspace.
	Type *string
}

WorkspacesClientListWorkspacesOptions contains the optional parameters for the WorkspacesClient.NewListWorkspacesPager method.

type WorkspacesClientListWorkspacesResponse 

type WorkspacesClientListWorkspacesResponse struct {
	// A list of workspaces.
	Workspaces
}

WorkspacesClientListWorkspacesResponse contains the response from method WorkspacesClient.NewListWorkspacesPager.

type WorkspacesClientRestoreWorkspaceOptions 

type WorkspacesClientRestoreWorkspaceOptions struct {
}

WorkspacesClientRestoreWorkspaceOptions contains the optional parameters for the WorkspacesClient.RestoreWorkspace method.

type WorkspacesClientRestoreWorkspaceResponse 

type WorkspacesClientRestoreWorkspaceResponse struct {
}

WorkspacesClientRestoreWorkspaceResponse contains the response from method WorkspacesClient.RestoreWorkspace.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.